Responses

Generated Pydantic models for shared.responses

pydantic model dakota.spec.shared.responses.AnalyticGradients

Analysis driver will return gradients

Show JSON schema

{
   "title": "AnalyticGradients",
   "description": "Analysis driver will return gradients",
   "type": "object",
   "properties": {
      "analytic_gradients": {
         "const": true,
         "default": true,
         "description": "Analysis driver will return gradients",
         "title": "Analytic Gradients",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.gradient_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "analytic"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• analytic_gradients (Literal[True])

field analytic_gradients: Literal[True] = True

Analysis driver will return gradients

pydantic model dakota.spec.shared.responses.AnalyticHessians

Hessians are needed and are available directly from the analysis driver

Show JSON schema

{
   "title": "AnalyticHessians",
   "description": "Hessians are needed and are available directly from the analysis driver",
   "type": "object",
   "properties": {
      "analytic_hessians": {
         "const": true,
         "default": true,
         "description": "Hessians are needed and are available directly from the analysis driver",
         "title": "Analytic Hessians",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "analytic"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• analytic_hessians (Literal[True])

field analytic_hessians: Literal[True] = True

Hessians are needed and are available directly from the analysis driver

pydantic model dakota.spec.shared.responses.IdNumericalHessians

Identify which numerical-Hessian corresponds to which response

Show JSON schema

{
   "title": "IdNumericalHessians",
   "description": "Identify which numerical-Hessian corresponds to which response",
   "type": "object",
   "properties": {
      "values": {
         "description": "Identify which numerical-Hessian corresponds to which response",
         "items": {
            "type": "integer"
         },
         "title": "Values",
         "type": "array",
         "x-materialization": [
            {
               "ir_key": "responses.hessians.mixed.id_numerical",
               "ir_value_type": "IntSet",
               "storage_type": "INT_SET"
            }
         ]
      },
      "fd_step_size": {
         "anyOf": [
            {
               "items": {
                  "type": "number"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Step size used when computing gradients and Hessians",
         "title": "Fd Step Size",
         "x-aliases": [
            "fd_hessian_step_size"
         ],
         "x-materialization": [
            {
               "ir_key": "responses.fd_hessian_step_size",
               "ir_value_type": "RealVector",
               "storage_type": "DIRECT_VALUE"
            }
         ]
      }
   },
   "additionalProperties": false,
   "required": [
      "values"
   ]
}

Fields:

• fd_step_size (list[float] | None)

• values (list[int])

field fd_step_size: list[DakotaFloat] | None = None

Step size used when computing gradients and Hessians

field values: list[int] [Required]

Identify which numerical-Hessian corresponds to which response

pydantic model dakota.spec.shared.responses.IdQuasiHessians

Identify which quasi-Hessian corresponds to which response

Show JSON schema

{
   "title": "IdQuasiHessians",
   "description": "Identify which quasi-Hessian corresponds to which response",
   "type": "object",
   "properties": {
      "values": {
         "description": "Identify which quasi-Hessian corresponds to which response",
         "items": {
            "type": "integer"
         },
         "title": "Values",
         "type": "array",
         "x-materialization": [
            {
               "ir_key": "responses.hessians.mixed.id_quasi",
               "ir_value_type": "IntSet",
               "storage_type": "INT_SET"
            }
         ]
      },
      "approximation": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/IdQuasiHessiansBfgs"
            },
            {
               "$ref": "#/$defs/IdQuasiHessiansSr1"
            }
         ],
         "description": "Quasi-Hessian Approximation",
         "title": "Approximation",
         "x-union-pattern": 4
      }
   },
   "$defs": {
      "IdQuasiHessiansBfgs": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "bfgs": {
               "$ref": "#/$defs/IdQuasiHessiansBfgsConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bfgs"
                  }
               ]
            }
         },
         "required": [
            "bfgs"
         ],
         "title": "IdQuasiHessiansBfgs",
         "type": "object"
      },
      "IdQuasiHessiansBfgsConfig": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "damped": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Numerical safeguarding for BFGS updates",
               "title": "Damped",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "damped_bfgs"
                  }
               ]
            }
         },
         "title": "IdQuasiHessiansBfgsConfig",
         "type": "object"
      },
      "IdQuasiHessiansSr1": {
         "additionalProperties": false,
         "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
         "properties": {
            "sr1": {
               "const": true,
               "default": true,
               "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
               "title": "Sr1",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "sr1"
                  }
               ]
            }
         },
         "title": "IdQuasiHessiansSr1",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "values",
      "approximation"
   ]
}

Fields:

• approximation (dakota.spec.shared.responses.IdQuasiHessiansBfgs | dakota.spec.shared.responses.IdQuasiHessiansSr1)

• values (list[int])

field approximation: IdQuasiHessiansBfgs | IdQuasiHessiansSr1 [Required]

Quasi-Hessian Approximation

field values: list[int] [Required]

Identify which quasi-Hessian corresponds to which response

pydantic model dakota.spec.shared.responses.IdQuasiHessiansBfgs

Use BFGS method to compute quasi-hessians

Show JSON schema

{
   "title": "IdQuasiHessiansBfgs",
   "description": "Use BFGS method to compute quasi-hessians",
   "type": "object",
   "properties": {
      "bfgs": {
         "$ref": "#/$defs/IdQuasiHessiansBfgsConfig",
         "x-materialization": [
            {
               "ir_key": "responses.quasi_hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "bfgs"
            }
         ]
      }
   },
   "$defs": {
      "IdQuasiHessiansBfgsConfig": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "damped": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Numerical safeguarding for BFGS updates",
               "title": "Damped",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "damped_bfgs"
                  }
               ]
            }
         },
         "title": "IdQuasiHessiansBfgsConfig",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "bfgs"
   ]
}

Fields:

• bfgs (dakota.spec.shared.responses.IdQuasiHessiansBfgsConfig)

field bfgs: IdQuasiHessiansBfgsConfig [Required]

Use BFGS method to compute quasi-hessians

pydantic model dakota.spec.shared.responses.IdQuasiHessiansBfgsConfig

Use BFGS method to compute quasi-hessians

Show JSON schema

{
   "title": "IdQuasiHessiansBfgsConfig",
   "description": "Use BFGS method to compute quasi-hessians",
   "type": "object",
   "properties": {
      "damped": {
         "anyOf": [
            {
               "const": true,
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Numerical safeguarding for BFGS updates",
         "title": "Damped",
         "x-materialization": [
            {
               "ir_key": "responses.quasi_hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "damped_bfgs"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• damped (Literal[True] | None)

field damped: Literal[True] | None = None

Numerical safeguarding for BFGS updates

pydantic model dakota.spec.shared.responses.IdQuasiHessiansSr1

Use the Symmetric Rank 1 update method to compute quasi-Hessians

Show JSON schema

{
   "title": "IdQuasiHessiansSr1",
   "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
   "type": "object",
   "properties": {
      "sr1": {
         "const": true,
         "default": true,
         "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
         "title": "Sr1",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.quasi_hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "sr1"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• sr1 (Literal[True])

field sr1: Literal[True] = True

Use the Symmetric Rank 1 update method to compute quasi-Hessians

pydantic model dakota.spec.shared.responses.MixedGradients

Gradients are needed and will be obtained from a mix of numerical and analytic sources

Show JSON schema

{
   "title": "MixedGradients",
   "description": "Gradients are needed and will be obtained from a mix of numerical and analytic sources",
   "type": "object",
   "properties": {
      "mixed_gradients": {
         "$ref": "#/$defs/MixedGradientsConfig",
         "x-materialization": [
            {
               "ir_key": "responses.gradient_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "mixed"
            }
         ]
      }
   },
   "$defs": {
      "MixedGradientsConfig": {
         "additionalProperties": false,
         "description": "Gradients are needed and will be obtained from a mix of numerical and analytic sources",
         "properties": {
            "id_numerical_gradients": {
               "description": "Identify which numerical gradient corresponds to which response",
               "items": {
                  "type": "integer"
               },
               "title": "Id Numerical Gradients",
               "type": "array",
               "x-materialization": [
                  {
                     "ir_key": "responses.gradients.mixed.id_numerical",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            },
            "id_analytic_gradients": {
               "description": "Identify which analytical gradient corresponds to which response",
               "items": {
                  "type": "integer"
               },
               "title": "Id Analytic Gradients",
               "type": "array",
               "x-materialization": [
                  {
                     "ir_key": "responses.gradients.mixed.id_analytic",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            },
            "method_source": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakota"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceVendor"
                  }
               ],
               "description": "Specify which finite difference routine is used",
               "title": "Method Source",
               "x-model-default": "MixedGradientsMethodSourceDakota",
               "x-union-pattern": 1
            },
            "interval_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedGradientsIntervalTypeForward"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsIntervalTypeCentral"
                  }
               ],
               "description": "Specify how to compute gradients and hessians",
               "title": "Interval Type",
               "x-model-default": "MixedGradientsIntervalTypeForward",
               "x-union-pattern": 1
            },
            "fd_step_size": {
               "anyOf": [
                  {
                     "items": {
                        "type": "number"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Step size used when computing gradients and Hessians",
               "title": "Fd Step Size",
               "x-aliases": [
                  "fd_gradient_step_size"
               ],
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_size",
                     "ir_value_type": "RealVector",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            }
         },
         "required": [
            "id_numerical_gradients",
            "id_analytic_gradients"
         ],
         "title": "MixedGradientsConfig",
         "type": "object"
      },
      "MixedGradientsIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "central"
                  }
               ]
            }
         },
         "title": "MixedGradientsIntervalTypeCentral",
         "type": "object"
      },
      "MixedGradientsIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "forward"
                  }
               ]
            }
         },
         "title": "MixedGradientsIntervalTypeForward",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakota": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "dakota": {
               "$ref": "#/$defs/MixedGradientsMethodSourceDakotaConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "dakota"
                  }
               ],
               "x-model-default": "MixedGradientsMethodSourceDakotaConfig"
            }
         },
         "title": "MixedGradientsMethodSourceDakota",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaBounds",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaConfig": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "ignore_bounds": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Do not respect bounds when computing gradients or Hessians",
               "title": "Ignore Bounds",
               "x-materialization": [
                  {
                     "ir_key": "responses.ignore_bounds",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaRelative"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaAbsolute"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "MixedGradientsMethodSourceDakotaRelative",
               "x-union-pattern": 1
            }
         },
         "title": "MixedGradientsMethodSourceDakotaConfig",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaRelative",
         "type": "object"
      },
      "MixedGradientsMethodSourceVendor": {
         "additionalProperties": false,
         "description": "Use non-Dakota fd algorithm",
         "properties": {
            "vendor": {
               "const": true,
               "default": true,
               "description": "Use non-Dakota fd algorithm",
               "title": "Vendor",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "vendor"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceVendor",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "mixed_gradients"
   ]
}

Fields:

• mixed_gradients (dakota.spec.shared.responses.MixedGradientsConfig)

field mixed_gradients: MixedGradientsConfig [Required]

Gradients are needed and will be obtained from a mix of numerical and analytic sources

pydantic model dakota.spec.shared.responses.MixedGradientsConfig

Gradients are needed and will be obtained from a mix of numerical and analytic sources

Show JSON schema

{
   "title": "MixedGradientsConfig",
   "description": "Gradients are needed and will be obtained from a mix of numerical and analytic sources",
   "type": "object",
   "properties": {
      "id_numerical_gradients": {
         "description": "Identify which numerical gradient corresponds to which response",
         "items": {
            "type": "integer"
         },
         "title": "Id Numerical Gradients",
         "type": "array",
         "x-materialization": [
            {
               "ir_key": "responses.gradients.mixed.id_numerical",
               "ir_value_type": "IntSet",
               "storage_type": "INT_SET"
            }
         ]
      },
      "id_analytic_gradients": {
         "description": "Identify which analytical gradient corresponds to which response",
         "items": {
            "type": "integer"
         },
         "title": "Id Analytic Gradients",
         "type": "array",
         "x-materialization": [
            {
               "ir_key": "responses.gradients.mixed.id_analytic",
               "ir_value_type": "IntSet",
               "storage_type": "INT_SET"
            }
         ]
      },
      "method_source": {
         "anyOf": [
            {
               "$ref": "#/$defs/MixedGradientsMethodSourceDakota"
            },
            {
               "$ref": "#/$defs/MixedGradientsMethodSourceVendor"
            }
         ],
         "description": "Specify which finite difference routine is used",
         "title": "Method Source",
         "x-model-default": "MixedGradientsMethodSourceDakota",
         "x-union-pattern": 1
      },
      "interval_type": {
         "anyOf": [
            {
               "$ref": "#/$defs/MixedGradientsIntervalTypeForward"
            },
            {
               "$ref": "#/$defs/MixedGradientsIntervalTypeCentral"
            }
         ],
         "description": "Specify how to compute gradients and hessians",
         "title": "Interval Type",
         "x-model-default": "MixedGradientsIntervalTypeForward",
         "x-union-pattern": 1
      },
      "fd_step_size": {
         "anyOf": [
            {
               "items": {
                  "type": "number"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Step size used when computing gradients and Hessians",
         "title": "Fd Step Size",
         "x-aliases": [
            "fd_gradient_step_size"
         ],
         "x-materialization": [
            {
               "ir_key": "responses.fd_gradient_step_size",
               "ir_value_type": "RealVector",
               "storage_type": "DIRECT_VALUE"
            }
         ]
      }
   },
   "$defs": {
      "MixedGradientsIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "central"
                  }
               ]
            }
         },
         "title": "MixedGradientsIntervalTypeCentral",
         "type": "object"
      },
      "MixedGradientsIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "forward"
                  }
               ]
            }
         },
         "title": "MixedGradientsIntervalTypeForward",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakota": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "dakota": {
               "$ref": "#/$defs/MixedGradientsMethodSourceDakotaConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "dakota"
                  }
               ],
               "x-model-default": "MixedGradientsMethodSourceDakotaConfig"
            }
         },
         "title": "MixedGradientsMethodSourceDakota",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaBounds",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaConfig": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "ignore_bounds": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Do not respect bounds when computing gradients or Hessians",
               "title": "Ignore Bounds",
               "x-materialization": [
                  {
                     "ir_key": "responses.ignore_bounds",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaRelative"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaAbsolute"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "MixedGradientsMethodSourceDakotaRelative",
               "x-union-pattern": 1
            }
         },
         "title": "MixedGradientsMethodSourceDakotaConfig",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaRelative",
         "type": "object"
      },
      "MixedGradientsMethodSourceVendor": {
         "additionalProperties": false,
         "description": "Use non-Dakota fd algorithm",
         "properties": {
            "vendor": {
               "const": true,
               "default": true,
               "description": "Use non-Dakota fd algorithm",
               "title": "Vendor",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "vendor"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceVendor",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "id_numerical_gradients",
      "id_analytic_gradients"
   ]
}

Fields:

• fd_step_size (list[float] | None)

• id_analytic_gradients (list[int])

• id_numerical_gradients (list[int])

• interval_type (dakota.spec.shared.responses.MixedGradientsIntervalTypeForward | dakota.spec.shared.responses.MixedGradientsIntervalTypeCentral)

• method_source (dakota.spec.shared.responses.MixedGradientsMethodSourceDakota | dakota.spec.shared.responses.MixedGradientsMethodSourceVendor)

field fd_step_size: list[DakotaFloat] | None = None

Step size used when computing gradients and Hessians

field id_analytic_gradients: list[int] [Required]

Identify which analytical gradient corresponds to which response

field id_numerical_gradients: list[int] [Required]

Identify which numerical gradient corresponds to which response

field interval_type: MixedGradientsIntervalTypeForward | MixedGradientsIntervalTypeCentral [Optional]

Specify how to compute gradients and hessians

field method_source: MixedGradientsMethodSourceDakota | MixedGradientsMethodSourceVendor [Optional]

Specify which finite difference routine is used

pydantic model dakota.spec.shared.responses.MixedGradientsIntervalTypeCentral

Use central differences

Show JSON schema

{
   "title": "MixedGradientsIntervalTypeCentral",
   "description": "Use central differences",
   "type": "object",
   "properties": {
      "central": {
         "const": true,
         "default": true,
         "description": "Use central differences",
         "title": "Central",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.interval_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "central"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• central (Literal[True])

field central: Literal[True] = True

Use central differences

pydantic model dakota.spec.shared.responses.MixedGradientsIntervalTypeForward

(Default) Use forward differences

Show JSON schema

{
   "title": "MixedGradientsIntervalTypeForward",
   "description": "(Default) Use forward differences",
   "type": "object",
   "properties": {
      "forward": {
         "const": true,
         "default": true,
         "description": "(Default) Use forward differences",
         "title": "Forward",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.interval_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "forward"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• forward (Literal[True])

field forward: Literal[True] = True

(Default) Use forward differences

pydantic model dakota.spec.shared.responses.MixedGradientsMethodSourceDakota

(Default) Use internal Dakota finite differences algorithm

Show JSON schema

{
   "title": "MixedGradientsMethodSourceDakota",
   "description": "(Default) Use internal Dakota finite differences algorithm",
   "type": "object",
   "properties": {
      "dakota": {
         "$ref": "#/$defs/MixedGradientsMethodSourceDakotaConfig",
         "x-materialization": [
            {
               "ir_key": "responses.method_source",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "dakota"
            }
         ],
         "x-model-default": "MixedGradientsMethodSourceDakotaConfig"
      }
   },
   "$defs": {
      "MixedGradientsMethodSourceDakotaAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaBounds",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaConfig": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "ignore_bounds": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Do not respect bounds when computing gradients or Hessians",
               "title": "Ignore Bounds",
               "x-materialization": [
                  {
                     "ir_key": "responses.ignore_bounds",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaRelative"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaAbsolute"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "MixedGradientsMethodSourceDakotaRelative",
               "x-union-pattern": 1
            }
         },
         "title": "MixedGradientsMethodSourceDakotaConfig",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaRelative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• dakota (dakota.spec.shared.responses.MixedGradientsMethodSourceDakotaConfig)

field dakota: MixedGradientsMethodSourceDakotaConfig [Optional]

(Default) Use internal Dakota finite differences algorithm

pydantic model dakota.spec.shared.responses.MixedGradientsMethodSourceDakotaAbsolute

Do not scale step-size

Show JSON schema

{
   "title": "MixedGradientsMethodSourceDakotaAbsolute",
   "description": "Do not scale step-size",
   "type": "object",
   "properties": {
      "absolute": {
         "const": true,
         "default": true,
         "description": "Do not scale step-size",
         "title": "Absolute",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_gradient_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "absolute"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• absolute (Literal[True])

field absolute: Literal[True] = True

Do not scale step-size

pydantic model dakota.spec.shared.responses.MixedGradientsMethodSourceDakotaBounds

Scale step-size by the domain of the parameter

Show JSON schema

{
   "title": "MixedGradientsMethodSourceDakotaBounds",
   "description": "Scale step-size by the domain of the parameter",
   "type": "object",
   "properties": {
      "bounds": {
         "const": true,
         "default": true,
         "description": "Scale step-size by the domain of the parameter",
         "title": "Bounds",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_gradient_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "bounds"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• bounds (Literal[True])

field bounds: Literal[True] = True

Scale step-size by the domain of the parameter

pydantic model dakota.spec.shared.responses.MixedGradientsMethodSourceDakotaConfig

(Default) Use internal Dakota finite differences algorithm

Show JSON schema

{
   "title": "MixedGradientsMethodSourceDakotaConfig",
   "description": "(Default) Use internal Dakota finite differences algorithm",
   "type": "object",
   "properties": {
      "ignore_bounds": {
         "anyOf": [
            {
               "const": true,
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Do not respect bounds when computing gradients or Hessians",
         "title": "Ignore Bounds",
         "x-materialization": [
            {
               "ir_key": "responses.ignore_bounds",
               "ir_value_type": "bool",
               "storage_type": "PRESENCE_TRUE"
            }
         ]
      },
      "step_scaling": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/MixedGradientsMethodSourceDakotaRelative"
            },
            {
               "$ref": "#/$defs/MixedGradientsMethodSourceDakotaAbsolute"
            },
            {
               "$ref": "#/$defs/MixedGradientsMethodSourceDakotaBounds"
            }
         ],
         "description": "Step Scaling",
         "title": "Step Scaling",
         "x-model-default": "MixedGradientsMethodSourceDakotaRelative",
         "x-union-pattern": 1
      }
   },
   "$defs": {
      "MixedGradientsMethodSourceDakotaAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaBounds",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaRelative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• ignore_bounds (Literal[True] | None)

• step_scaling (dakota.spec.shared.responses.MixedGradientsMethodSourceDakotaRelative | dakota.spec.shared.responses.MixedGradientsMethodSourceDakotaAbsolute | dakota.spec.shared.responses.MixedGradientsMethodSourceDakotaBounds)

field ignore_bounds: Literal[True] | None = None

Do not respect bounds when computing gradients or Hessians

field step_scaling: MixedGradientsMethodSourceDakotaRelative | MixedGradientsMethodSourceDakotaAbsolute | MixedGradientsMethodSourceDakotaBounds [Optional]

Step Scaling

pydantic model dakota.spec.shared.responses.MixedGradientsMethodSourceDakotaRelative

(Default) Scale step size by the parameter value

Show JSON schema

{
   "title": "MixedGradientsMethodSourceDakotaRelative",
   "description": "(Default) Scale step size by the parameter value",
   "type": "object",
   "properties": {
      "relative": {
         "const": true,
         "default": true,
         "description": "(Default) Scale step size by the parameter value",
         "title": "Relative",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_gradient_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "relative"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• relative (Literal[True])

field relative: Literal[True] = True

(Default) Scale step size by the parameter value

pydantic model dakota.spec.shared.responses.MixedGradientsMethodSourceVendor

Use non-Dakota fd algorithm

Show JSON schema

{
   "title": "MixedGradientsMethodSourceVendor",
   "description": "Use non-Dakota fd algorithm",
   "type": "object",
   "properties": {
      "vendor": {
         "const": true,
         "default": true,
         "description": "Use non-Dakota fd algorithm",
         "title": "Vendor",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.method_source",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "vendor"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• vendor (Literal[True])

field vendor: Literal[True] = True

Use non-Dakota fd algorithm

pydantic model dakota.spec.shared.responses.MixedHessians

Hessians are needed and will be obtained from a mix of numerical, analytic, and "quasi" sources

Show JSON schema

{
   "title": "MixedHessians",
   "description": "Hessians are needed and will be obtained from a mix of numerical, analytic, and \\\"quasi\\\" sources",
   "type": "object",
   "properties": {
      "mixed_hessians": {
         "$ref": "#/$defs/MixedHessiansConfig",
         "description": "Hessians are needed and will be obtained from a mix of numerical, analytic, and \"quasi\" sources",
         "x-materialization": [
            {
               "ir_key": "responses.hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "mixed"
            }
         ]
      }
   },
   "$defs": {
      "IdNumericalHessians": {
         "additionalProperties": false,
         "description": "Identify which numerical-Hessian corresponds to which response",
         "properties": {
            "values": {
               "description": "Identify which numerical-Hessian corresponds to which response",
               "items": {
                  "type": "integer"
               },
               "title": "Values",
               "type": "array",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessians.mixed.id_numerical",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            },
            "fd_step_size": {
               "anyOf": [
                  {
                     "items": {
                        "type": "number"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Step size used when computing gradients and Hessians",
               "title": "Fd Step Size",
               "x-aliases": [
                  "fd_hessian_step_size"
               ],
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_size",
                     "ir_value_type": "RealVector",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            }
         },
         "required": [
            "values"
         ],
         "title": "IdNumericalHessians",
         "type": "object"
      },
      "IdQuasiHessians": {
         "additionalProperties": false,
         "description": "Identify which quasi-Hessian corresponds to which response",
         "properties": {
            "values": {
               "description": "Identify which quasi-Hessian corresponds to which response",
               "items": {
                  "type": "integer"
               },
               "title": "Values",
               "type": "array",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessians.mixed.id_quasi",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            },
            "approximation": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/IdQuasiHessiansBfgs"
                  },
                  {
                     "$ref": "#/$defs/IdQuasiHessiansSr1"
                  }
               ],
               "description": "Quasi-Hessian Approximation",
               "title": "Approximation",
               "x-union-pattern": 4
            }
         },
         "required": [
            "values",
            "approximation"
         ],
         "title": "IdQuasiHessians",
         "type": "object"
      },
      "IdQuasiHessiansBfgs": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "bfgs": {
               "$ref": "#/$defs/IdQuasiHessiansBfgsConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bfgs"
                  }
               ]
            }
         },
         "required": [
            "bfgs"
         ],
         "title": "IdQuasiHessiansBfgs",
         "type": "object"
      },
      "IdQuasiHessiansBfgsConfig": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "damped": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Numerical safeguarding for BFGS updates",
               "title": "Damped",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "damped_bfgs"
                  }
               ]
            }
         },
         "title": "IdQuasiHessiansBfgsConfig",
         "type": "object"
      },
      "IdQuasiHessiansSr1": {
         "additionalProperties": false,
         "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
         "properties": {
            "sr1": {
               "const": true,
               "default": true,
               "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
               "title": "Sr1",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "sr1"
                  }
               ]
            }
         },
         "title": "IdQuasiHessiansSr1",
         "type": "object"
      },
      "MixedHessiansAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "MixedHessiansAbsolute",
         "type": "object"
      },
      "MixedHessiansBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "MixedHessiansBounds",
         "type": "object"
      },
      "MixedHessiansConfig": {
         "additionalProperties": false,
         "description": "Hessians are needed and will be obtained from a mix of numerical, analytic, and \\\"quasi\\\" sources",
         "properties": {
            "id_numerical_hessians": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/IdNumericalHessians"
                  },
                  {
                     "type": "null"
                  }
               ],
               "argument": "values",
               "default": null,
               "description": "Identify which numerical-Hessian corresponds to which response"
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedHessiansRelative"
                  },
                  {
                     "$ref": "#/$defs/MixedHessiansAbsolute"
                  },
                  {
                     "$ref": "#/$defs/MixedHessiansBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "MixedHessiansRelative",
               "x-union-pattern": 1
            },
            "interval_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedHessiansIntervalTypeForward"
                  },
                  {
                     "$ref": "#/$defs/MixedHessiansIntervalTypeCentral"
                  }
               ],
               "description": "Specify how to compute gradients and hessians",
               "title": "Interval Type",
               "x-model-default": "MixedHessiansIntervalTypeForward",
               "x-union-pattern": 1
            },
            "id_quasi_hessians": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/IdQuasiHessians"
                  },
                  {
                     "type": "null"
                  }
               ],
               "argument": "values",
               "default": null,
               "description": "Identify which quasi-Hessian corresponds to which response"
            },
            "id_analytic_hessians": {
               "anyOf": [
                  {
                     "items": {
                        "type": "integer"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Identify which analytical Hessian corresponds to which response",
               "title": "Id Analytic Hessians",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessians.mixed.id_analytic",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            }
         },
         "title": "MixedHessiansConfig",
         "type": "object"
      },
      "MixedHessiansIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            }
         },
         "title": "MixedHessiansIntervalTypeCentral",
         "type": "object"
      },
      "MixedHessiansIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_FALSE"
                  }
               ]
            }
         },
         "title": "MixedHessiansIntervalTypeForward",
         "type": "object"
      },
      "MixedHessiansRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "MixedHessiansRelative",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "mixed_hessians"
   ]
}

Fields:

• mixed_hessians (dakota.spec.shared.responses.MixedHessiansConfig)

field mixed_hessians: MixedHessiansConfig [Required]

Hessians are needed and will be obtained from a mix of numerical, analytic, and “quasi” sources

pydantic model dakota.spec.shared.responses.MixedHessiansAbsolute

Do not scale step-size

Show JSON schema

{
   "title": "MixedHessiansAbsolute",
   "description": "Do not scale step-size",
   "type": "object",
   "properties": {
      "absolute": {
         "const": true,
         "default": true,
         "description": "Do not scale step-size",
         "title": "Absolute",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_hessian_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "absolute"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• absolute (Literal[True])

field absolute: Literal[True] = True

Do not scale step-size

pydantic model dakota.spec.shared.responses.MixedHessiansBounds

Scale step-size by the domain of the parameter

Show JSON schema

{
   "title": "MixedHessiansBounds",
   "description": "Scale step-size by the domain of the parameter",
   "type": "object",
   "properties": {
      "bounds": {
         "const": true,
         "default": true,
         "description": "Scale step-size by the domain of the parameter",
         "title": "Bounds",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_hessian_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "bounds"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• bounds (Literal[True])

field bounds: Literal[True] = True

Scale step-size by the domain of the parameter

pydantic model dakota.spec.shared.responses.MixedHessiansConfig

Hessians are needed and will be obtained from a mix of numerical, analytic, and "quasi" sources

Show JSON schema

{
   "title": "MixedHessiansConfig",
   "description": "Hessians are needed and will be obtained from a mix of numerical, analytic, and \\\"quasi\\\" sources",
   "type": "object",
   "properties": {
      "id_numerical_hessians": {
         "anyOf": [
            {
               "$ref": "#/$defs/IdNumericalHessians"
            },
            {
               "type": "null"
            }
         ],
         "argument": "values",
         "default": null,
         "description": "Identify which numerical-Hessian corresponds to which response"
      },
      "step_scaling": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/MixedHessiansRelative"
            },
            {
               "$ref": "#/$defs/MixedHessiansAbsolute"
            },
            {
               "$ref": "#/$defs/MixedHessiansBounds"
            }
         ],
         "description": "Step Scaling",
         "title": "Step Scaling",
         "x-model-default": "MixedHessiansRelative",
         "x-union-pattern": 1
      },
      "interval_type": {
         "anyOf": [
            {
               "$ref": "#/$defs/MixedHessiansIntervalTypeForward"
            },
            {
               "$ref": "#/$defs/MixedHessiansIntervalTypeCentral"
            }
         ],
         "description": "Specify how to compute gradients and hessians",
         "title": "Interval Type",
         "x-model-default": "MixedHessiansIntervalTypeForward",
         "x-union-pattern": 1
      },
      "id_quasi_hessians": {
         "anyOf": [
            {
               "$ref": "#/$defs/IdQuasiHessians"
            },
            {
               "type": "null"
            }
         ],
         "argument": "values",
         "default": null,
         "description": "Identify which quasi-Hessian corresponds to which response"
      },
      "id_analytic_hessians": {
         "anyOf": [
            {
               "items": {
                  "type": "integer"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Identify which analytical Hessian corresponds to which response",
         "title": "Id Analytic Hessians",
         "x-materialization": [
            {
               "ir_key": "responses.hessians.mixed.id_analytic",
               "ir_value_type": "IntSet",
               "storage_type": "INT_SET"
            }
         ]
      }
   },
   "$defs": {
      "IdNumericalHessians": {
         "additionalProperties": false,
         "description": "Identify which numerical-Hessian corresponds to which response",
         "properties": {
            "values": {
               "description": "Identify which numerical-Hessian corresponds to which response",
               "items": {
                  "type": "integer"
               },
               "title": "Values",
               "type": "array",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessians.mixed.id_numerical",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            },
            "fd_step_size": {
               "anyOf": [
                  {
                     "items": {
                        "type": "number"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Step size used when computing gradients and Hessians",
               "title": "Fd Step Size",
               "x-aliases": [
                  "fd_hessian_step_size"
               ],
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_size",
                     "ir_value_type": "RealVector",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            }
         },
         "required": [
            "values"
         ],
         "title": "IdNumericalHessians",
         "type": "object"
      },
      "IdQuasiHessians": {
         "additionalProperties": false,
         "description": "Identify which quasi-Hessian corresponds to which response",
         "properties": {
            "values": {
               "description": "Identify which quasi-Hessian corresponds to which response",
               "items": {
                  "type": "integer"
               },
               "title": "Values",
               "type": "array",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessians.mixed.id_quasi",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            },
            "approximation": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/IdQuasiHessiansBfgs"
                  },
                  {
                     "$ref": "#/$defs/IdQuasiHessiansSr1"
                  }
               ],
               "description": "Quasi-Hessian Approximation",
               "title": "Approximation",
               "x-union-pattern": 4
            }
         },
         "required": [
            "values",
            "approximation"
         ],
         "title": "IdQuasiHessians",
         "type": "object"
      },
      "IdQuasiHessiansBfgs": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "bfgs": {
               "$ref": "#/$defs/IdQuasiHessiansBfgsConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bfgs"
                  }
               ]
            }
         },
         "required": [
            "bfgs"
         ],
         "title": "IdQuasiHessiansBfgs",
         "type": "object"
      },
      "IdQuasiHessiansBfgsConfig": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "damped": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Numerical safeguarding for BFGS updates",
               "title": "Damped",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "damped_bfgs"
                  }
               ]
            }
         },
         "title": "IdQuasiHessiansBfgsConfig",
         "type": "object"
      },
      "IdQuasiHessiansSr1": {
         "additionalProperties": false,
         "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
         "properties": {
            "sr1": {
               "const": true,
               "default": true,
               "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
               "title": "Sr1",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "sr1"
                  }
               ]
            }
         },
         "title": "IdQuasiHessiansSr1",
         "type": "object"
      },
      "MixedHessiansAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "MixedHessiansAbsolute",
         "type": "object"
      },
      "MixedHessiansBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "MixedHessiansBounds",
         "type": "object"
      },
      "MixedHessiansIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            }
         },
         "title": "MixedHessiansIntervalTypeCentral",
         "type": "object"
      },
      "MixedHessiansIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_FALSE"
                  }
               ]
            }
         },
         "title": "MixedHessiansIntervalTypeForward",
         "type": "object"
      },
      "MixedHessiansRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "MixedHessiansRelative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• id_analytic_hessians (list[int] | None)

• id_numerical_hessians (dakota.spec.shared.responses.IdNumericalHessians | None)

• id_quasi_hessians (dakota.spec.shared.responses.IdQuasiHessians | None)

• interval_type (dakota.spec.shared.responses.MixedHessiansIntervalTypeForward | dakota.spec.shared.responses.MixedHessiansIntervalTypeCentral)

• step_scaling (dakota.spec.shared.responses.MixedHessiansRelative | dakota.spec.shared.responses.MixedHessiansAbsolute | dakota.spec.shared.responses.MixedHessiansBounds)

field id_analytic_hessians: list[int] | None = None

Identify which analytical Hessian corresponds to which response

field id_numerical_hessians: IdNumericalHessians | None = None

Identify which numerical-Hessian corresponds to which response

field id_quasi_hessians: IdQuasiHessians | None = None

Identify which quasi-Hessian corresponds to which response

field interval_type: MixedHessiansIntervalTypeForward | MixedHessiansIntervalTypeCentral [Optional]

Specify how to compute gradients and hessians

field step_scaling: MixedHessiansRelative | MixedHessiansAbsolute | MixedHessiansBounds [Optional]

Step Scaling

pydantic model dakota.spec.shared.responses.MixedHessiansIntervalTypeCentral

Use central differences

Show JSON schema

{
   "title": "MixedHessiansIntervalTypeCentral",
   "description": "Use central differences",
   "type": "object",
   "properties": {
      "central": {
         "const": true,
         "default": true,
         "description": "Use central differences",
         "title": "Central",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.central_hess",
               "ir_value_type": "bool",
               "storage_type": "PRESENCE_TRUE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• central (Literal[True])

field central: Literal[True] = True

Use central differences

pydantic model dakota.spec.shared.responses.MixedHessiansIntervalTypeForward

(Default) Use forward differences

Show JSON schema

{
   "title": "MixedHessiansIntervalTypeForward",
   "description": "(Default) Use forward differences",
   "type": "object",
   "properties": {
      "forward": {
         "const": true,
         "default": true,
         "description": "(Default) Use forward differences",
         "title": "Forward",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.central_hess",
               "ir_value_type": "bool",
               "storage_type": "PRESENCE_FALSE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• forward (Literal[True])

field forward: Literal[True] = True

(Default) Use forward differences

pydantic model dakota.spec.shared.responses.MixedHessiansRelative

(Default) Scale step size by the parameter value

Show JSON schema

{
   "title": "MixedHessiansRelative",
   "description": "(Default) Scale step size by the parameter value",
   "type": "object",
   "properties": {
      "relative": {
         "const": true,
         "default": true,
         "description": "(Default) Scale step size by the parameter value",
         "title": "Relative",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_hessian_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "relative"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• relative (Literal[True])

field relative: Literal[True] = True

(Default) Scale step size by the parameter value

pydantic model dakota.spec.shared.responses.NoGradients

Gradients will not be used

Show JSON schema

{
   "title": "NoGradients",
   "description": "Gradients will not be used",
   "type": "object",
   "properties": {
      "no_gradients": {
         "const": true,
         "default": true,
         "description": "Gradients will not be used",
         "title": "No Gradients",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.gradient_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "none"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• no_gradients (Literal[True])

field no_gradients: Literal[True] = True

Gradients will not be used

pydantic model dakota.spec.shared.responses.NoHessians

Hessians will not be used

Show JSON schema

{
   "title": "NoHessians",
   "description": "Hessians will not be used",
   "type": "object",
   "properties": {
      "no_hessians": {
         "const": true,
         "default": true,
         "description": "Hessians will not be used",
         "title": "No Hessians",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "none"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• no_hessians (Literal[True])

field no_hessians: Literal[True] = True

Hessians will not be used

pydantic model dakota.spec.shared.responses.NumericalGradients

Gradients are needed and will be approximated by finite differences

Show JSON schema

{
   "title": "NumericalGradients",
   "description": "Gradients are needed and will be approximated by finite differences",
   "type": "object",
   "properties": {
      "numerical_gradients": {
         "$ref": "#/$defs/NumericalGradientsConfig",
         "x-materialization": [
            {
               "ir_key": "responses.gradient_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "numerical"
            }
         ]
      }
   },
   "$defs": {
      "NumericalGradientsConfig": {
         "additionalProperties": false,
         "description": "Gradients are needed and will be approximated by finite differences",
         "properties": {
            "method_source": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakota"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceVendor"
                  }
               ],
               "description": "Specify which finite difference routine is used",
               "title": "Method Source",
               "x-model-default": "NumericalGradientsMethodSourceDakota",
               "x-union-pattern": 1
            },
            "interval_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalGradientsIntervalTypeForward"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsIntervalTypeCentral"
                  }
               ],
               "description": "Specify how to compute gradients and hessians",
               "title": "Interval Type",
               "x-model-default": "NumericalGradientsIntervalTypeForward",
               "x-union-pattern": 1
            },
            "fd_step_size": {
               "anyOf": [
                  {
                     "items": {
                        "type": "number"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Step size used when computing gradients and Hessians",
               "title": "Fd Step Size",
               "x-aliases": [
                  "fd_gradient_step_size"
               ],
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_size",
                     "ir_value_type": "RealVector",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            }
         },
         "title": "NumericalGradientsConfig",
         "type": "object"
      },
      "NumericalGradientsIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "central"
                  }
               ]
            }
         },
         "title": "NumericalGradientsIntervalTypeCentral",
         "type": "object"
      },
      "NumericalGradientsIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "forward"
                  }
               ]
            }
         },
         "title": "NumericalGradientsIntervalTypeForward",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakota": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "dakota": {
               "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "dakota"
                  }
               ],
               "x-model-default": "NumericalGradientsMethodSourceDakotaConfig"
            }
         },
         "title": "NumericalGradientsMethodSourceDakota",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaBounds",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaConfig": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "ignore_bounds": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Do not respect bounds when computing gradients or Hessians",
               "title": "Ignore Bounds",
               "x-materialization": [
                  {
                     "ir_key": "responses.ignore_bounds",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaRelative"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaAbsolute"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "NumericalGradientsMethodSourceDakotaRelative",
               "x-union-pattern": 1
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaConfig",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaRelative",
         "type": "object"
      },
      "NumericalGradientsMethodSourceVendor": {
         "additionalProperties": false,
         "description": "Use non-Dakota fd algorithm",
         "properties": {
            "vendor": {
               "const": true,
               "default": true,
               "description": "Use non-Dakota fd algorithm",
               "title": "Vendor",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "vendor"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceVendor",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "numerical_gradients"
   ]
}

Fields:

• numerical_gradients (dakota.spec.shared.responses.NumericalGradientsConfig)

field numerical_gradients: NumericalGradientsConfig [Required]

Gradients are needed and will be approximated by finite differences

pydantic model dakota.spec.shared.responses.NumericalGradientsConfig

Gradients are needed and will be approximated by finite differences

Show JSON schema

{
   "title": "NumericalGradientsConfig",
   "description": "Gradients are needed and will be approximated by finite differences",
   "type": "object",
   "properties": {
      "method_source": {
         "anyOf": [
            {
               "$ref": "#/$defs/NumericalGradientsMethodSourceDakota"
            },
            {
               "$ref": "#/$defs/NumericalGradientsMethodSourceVendor"
            }
         ],
         "description": "Specify which finite difference routine is used",
         "title": "Method Source",
         "x-model-default": "NumericalGradientsMethodSourceDakota",
         "x-union-pattern": 1
      },
      "interval_type": {
         "anyOf": [
            {
               "$ref": "#/$defs/NumericalGradientsIntervalTypeForward"
            },
            {
               "$ref": "#/$defs/NumericalGradientsIntervalTypeCentral"
            }
         ],
         "description": "Specify how to compute gradients and hessians",
         "title": "Interval Type",
         "x-model-default": "NumericalGradientsIntervalTypeForward",
         "x-union-pattern": 1
      },
      "fd_step_size": {
         "anyOf": [
            {
               "items": {
                  "type": "number"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Step size used when computing gradients and Hessians",
         "title": "Fd Step Size",
         "x-aliases": [
            "fd_gradient_step_size"
         ],
         "x-materialization": [
            {
               "ir_key": "responses.fd_gradient_step_size",
               "ir_value_type": "RealVector",
               "storage_type": "DIRECT_VALUE"
            }
         ]
      }
   },
   "$defs": {
      "NumericalGradientsIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "central"
                  }
               ]
            }
         },
         "title": "NumericalGradientsIntervalTypeCentral",
         "type": "object"
      },
      "NumericalGradientsIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "forward"
                  }
               ]
            }
         },
         "title": "NumericalGradientsIntervalTypeForward",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakota": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "dakota": {
               "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "dakota"
                  }
               ],
               "x-model-default": "NumericalGradientsMethodSourceDakotaConfig"
            }
         },
         "title": "NumericalGradientsMethodSourceDakota",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaBounds",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaConfig": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "ignore_bounds": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Do not respect bounds when computing gradients or Hessians",
               "title": "Ignore Bounds",
               "x-materialization": [
                  {
                     "ir_key": "responses.ignore_bounds",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaRelative"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaAbsolute"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "NumericalGradientsMethodSourceDakotaRelative",
               "x-union-pattern": 1
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaConfig",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaRelative",
         "type": "object"
      },
      "NumericalGradientsMethodSourceVendor": {
         "additionalProperties": false,
         "description": "Use non-Dakota fd algorithm",
         "properties": {
            "vendor": {
               "const": true,
               "default": true,
               "description": "Use non-Dakota fd algorithm",
               "title": "Vendor",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "vendor"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceVendor",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• fd_step_size (list[float] | None)

• interval_type (dakota.spec.shared.responses.NumericalGradientsIntervalTypeForward | dakota.spec.shared.responses.NumericalGradientsIntervalTypeCentral)

• method_source (dakota.spec.shared.responses.NumericalGradientsMethodSourceDakota | dakota.spec.shared.responses.NumericalGradientsMethodSourceVendor)

field fd_step_size: list[DakotaFloat] | None = None

Step size used when computing gradients and Hessians

field interval_type: NumericalGradientsIntervalTypeForward | NumericalGradientsIntervalTypeCentral [Optional]

Specify how to compute gradients and hessians

field method_source: NumericalGradientsMethodSourceDakota | NumericalGradientsMethodSourceVendor [Optional]

Specify which finite difference routine is used

pydantic model dakota.spec.shared.responses.NumericalGradientsIntervalTypeCentral

Use central differences

Show JSON schema

{
   "title": "NumericalGradientsIntervalTypeCentral",
   "description": "Use central differences",
   "type": "object",
   "properties": {
      "central": {
         "const": true,
         "default": true,
         "description": "Use central differences",
         "title": "Central",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.interval_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "central"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• central (Literal[True])

field central: Literal[True] = True

Use central differences

pydantic model dakota.spec.shared.responses.NumericalGradientsIntervalTypeForward

(Default) Use forward differences

Show JSON schema

{
   "title": "NumericalGradientsIntervalTypeForward",
   "description": "(Default) Use forward differences",
   "type": "object",
   "properties": {
      "forward": {
         "const": true,
         "default": true,
         "description": "(Default) Use forward differences",
         "title": "Forward",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.interval_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "forward"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• forward (Literal[True])

field forward: Literal[True] = True

(Default) Use forward differences

pydantic model dakota.spec.shared.responses.NumericalGradientsMethodSourceDakota

(Default) Use internal Dakota finite differences algorithm

Show JSON schema

{
   "title": "NumericalGradientsMethodSourceDakota",
   "description": "(Default) Use internal Dakota finite differences algorithm",
   "type": "object",
   "properties": {
      "dakota": {
         "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaConfig",
         "x-materialization": [
            {
               "ir_key": "responses.method_source",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "dakota"
            }
         ],
         "x-model-default": "NumericalGradientsMethodSourceDakotaConfig"
      }
   },
   "$defs": {
      "NumericalGradientsMethodSourceDakotaAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaBounds",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaConfig": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "ignore_bounds": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Do not respect bounds when computing gradients or Hessians",
               "title": "Ignore Bounds",
               "x-materialization": [
                  {
                     "ir_key": "responses.ignore_bounds",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaRelative"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaAbsolute"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "NumericalGradientsMethodSourceDakotaRelative",
               "x-union-pattern": 1
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaConfig",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaRelative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• dakota (dakota.spec.shared.responses.NumericalGradientsMethodSourceDakotaConfig)

field dakota: NumericalGradientsMethodSourceDakotaConfig [Optional]

(Default) Use internal Dakota finite differences algorithm

pydantic model dakota.spec.shared.responses.NumericalGradientsMethodSourceDakotaAbsolute

Do not scale step-size

Show JSON schema

{
   "title": "NumericalGradientsMethodSourceDakotaAbsolute",
   "description": "Do not scale step-size",
   "type": "object",
   "properties": {
      "absolute": {
         "const": true,
         "default": true,
         "description": "Do not scale step-size",
         "title": "Absolute",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_gradient_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "absolute"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• absolute (Literal[True])

field absolute: Literal[True] = True

Do not scale step-size

pydantic model dakota.spec.shared.responses.NumericalGradientsMethodSourceDakotaBounds

Scale step-size by the domain of the parameter

Show JSON schema

{
   "title": "NumericalGradientsMethodSourceDakotaBounds",
   "description": "Scale step-size by the domain of the parameter",
   "type": "object",
   "properties": {
      "bounds": {
         "const": true,
         "default": true,
         "description": "Scale step-size by the domain of the parameter",
         "title": "Bounds",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_gradient_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "bounds"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• bounds (Literal[True])

field bounds: Literal[True] = True

Scale step-size by the domain of the parameter

pydantic model dakota.spec.shared.responses.NumericalGradientsMethodSourceDakotaConfig

(Default) Use internal Dakota finite differences algorithm

Show JSON schema

{
   "title": "NumericalGradientsMethodSourceDakotaConfig",
   "description": "(Default) Use internal Dakota finite differences algorithm",
   "type": "object",
   "properties": {
      "ignore_bounds": {
         "anyOf": [
            {
               "const": true,
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Do not respect bounds when computing gradients or Hessians",
         "title": "Ignore Bounds",
         "x-materialization": [
            {
               "ir_key": "responses.ignore_bounds",
               "ir_value_type": "bool",
               "storage_type": "PRESENCE_TRUE"
            }
         ]
      },
      "step_scaling": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaRelative"
            },
            {
               "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaAbsolute"
            },
            {
               "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaBounds"
            }
         ],
         "description": "Step Scaling",
         "title": "Step Scaling",
         "x-model-default": "NumericalGradientsMethodSourceDakotaRelative",
         "x-union-pattern": 1
      }
   },
   "$defs": {
      "NumericalGradientsMethodSourceDakotaAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaBounds",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaRelative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• ignore_bounds (Literal[True] | None)

• step_scaling (dakota.spec.shared.responses.NumericalGradientsMethodSourceDakotaRelative | dakota.spec.shared.responses.NumericalGradientsMethodSourceDakotaAbsolute | dakota.spec.shared.responses.NumericalGradientsMethodSourceDakotaBounds)

field ignore_bounds: Literal[True] | None = None

Do not respect bounds when computing gradients or Hessians

field step_scaling: NumericalGradientsMethodSourceDakotaRelative | NumericalGradientsMethodSourceDakotaAbsolute | NumericalGradientsMethodSourceDakotaBounds [Optional]

Step Scaling

pydantic model dakota.spec.shared.responses.NumericalGradientsMethodSourceDakotaRelative

(Default) Scale step size by the parameter value

Show JSON schema

{
   "title": "NumericalGradientsMethodSourceDakotaRelative",
   "description": "(Default) Scale step size by the parameter value",
   "type": "object",
   "properties": {
      "relative": {
         "const": true,
         "default": true,
         "description": "(Default) Scale step size by the parameter value",
         "title": "Relative",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_gradient_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "relative"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• relative (Literal[True])

field relative: Literal[True] = True

(Default) Scale step size by the parameter value

pydantic model dakota.spec.shared.responses.NumericalGradientsMethodSourceVendor

Use non-Dakota fd algorithm

Show JSON schema

{
   "title": "NumericalGradientsMethodSourceVendor",
   "description": "Use non-Dakota fd algorithm",
   "type": "object",
   "properties": {
      "vendor": {
         "const": true,
         "default": true,
         "description": "Use non-Dakota fd algorithm",
         "title": "Vendor",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.method_source",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "vendor"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• vendor (Literal[True])

field vendor: Literal[True] = True

Use non-Dakota fd algorithm

pydantic model dakota.spec.shared.responses.NumericalHessians

Hessians are needed and will be approximated by finite differences

Show JSON schema

{
   "title": "NumericalHessians",
   "description": "Hessians are needed and will be approximated by finite differences",
   "type": "object",
   "properties": {
      "numerical_hessians": {
         "$ref": "#/$defs/NumericalHessiansConfig",
         "x-materialization": [
            {
               "ir_key": "responses.hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "numerical"
            }
         ]
      }
   },
   "$defs": {
      "NumericalHessiansAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "NumericalHessiansAbsolute",
         "type": "object"
      },
      "NumericalHessiansBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "NumericalHessiansBounds",
         "type": "object"
      },
      "NumericalHessiansConfig": {
         "additionalProperties": false,
         "description": "Hessians are needed and will be approximated by finite differences",
         "properties": {
            "fd_step_size": {
               "anyOf": [
                  {
                     "items": {
                        "type": "number"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Step size used when computing gradients and Hessians",
               "title": "Fd Step Size",
               "x-aliases": [
                  "fd_hessian_step_size"
               ],
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_size",
                     "ir_value_type": "RealVector",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalHessiansRelative"
                  },
                  {
                     "$ref": "#/$defs/NumericalHessiansAbsolute"
                  },
                  {
                     "$ref": "#/$defs/NumericalHessiansBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "NumericalHessiansRelative",
               "x-union-pattern": 1
            },
            "interval_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalHessiansIntervalTypeForward"
                  },
                  {
                     "$ref": "#/$defs/NumericalHessiansIntervalTypeCentral"
                  }
               ],
               "description": "Specify how to compute gradients and hessians",
               "title": "Interval Type",
               "x-model-default": "NumericalHessiansIntervalTypeForward",
               "x-union-pattern": 1
            }
         },
         "title": "NumericalHessiansConfig",
         "type": "object"
      },
      "NumericalHessiansIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            }
         },
         "title": "NumericalHessiansIntervalTypeCentral",
         "type": "object"
      },
      "NumericalHessiansIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_FALSE"
                  }
               ]
            }
         },
         "title": "NumericalHessiansIntervalTypeForward",
         "type": "object"
      },
      "NumericalHessiansRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "NumericalHessiansRelative",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "numerical_hessians"
   ]
}

Fields:

• numerical_hessians (dakota.spec.shared.responses.NumericalHessiansConfig)

field numerical_hessians: NumericalHessiansConfig [Required]

Hessians are needed and will be approximated by finite differences

pydantic model dakota.spec.shared.responses.NumericalHessiansAbsolute

Do not scale step-size

Show JSON schema

{
   "title": "NumericalHessiansAbsolute",
   "description": "Do not scale step-size",
   "type": "object",
   "properties": {
      "absolute": {
         "const": true,
         "default": true,
         "description": "Do not scale step-size",
         "title": "Absolute",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_hessian_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "absolute"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• absolute (Literal[True])

field absolute: Literal[True] = True

Do not scale step-size

pydantic model dakota.spec.shared.responses.NumericalHessiansBounds

Scale step-size by the domain of the parameter

Show JSON schema

{
   "title": "NumericalHessiansBounds",
   "description": "Scale step-size by the domain of the parameter",
   "type": "object",
   "properties": {
      "bounds": {
         "const": true,
         "default": true,
         "description": "Scale step-size by the domain of the parameter",
         "title": "Bounds",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_hessian_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "bounds"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• bounds (Literal[True])

field bounds: Literal[True] = True

Scale step-size by the domain of the parameter

pydantic model dakota.spec.shared.responses.NumericalHessiansConfig

Hessians are needed and will be approximated by finite differences

Show JSON schema

{
   "title": "NumericalHessiansConfig",
   "description": "Hessians are needed and will be approximated by finite differences",
   "type": "object",
   "properties": {
      "fd_step_size": {
         "anyOf": [
            {
               "items": {
                  "type": "number"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Step size used when computing gradients and Hessians",
         "title": "Fd Step Size",
         "x-aliases": [
            "fd_hessian_step_size"
         ],
         "x-materialization": [
            {
               "ir_key": "responses.fd_hessian_step_size",
               "ir_value_type": "RealVector",
               "storage_type": "DIRECT_VALUE"
            }
         ]
      },
      "step_scaling": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/NumericalHessiansRelative"
            },
            {
               "$ref": "#/$defs/NumericalHessiansAbsolute"
            },
            {
               "$ref": "#/$defs/NumericalHessiansBounds"
            }
         ],
         "description": "Step Scaling",
         "title": "Step Scaling",
         "x-model-default": "NumericalHessiansRelative",
         "x-union-pattern": 1
      },
      "interval_type": {
         "anyOf": [
            {
               "$ref": "#/$defs/NumericalHessiansIntervalTypeForward"
            },
            {
               "$ref": "#/$defs/NumericalHessiansIntervalTypeCentral"
            }
         ],
         "description": "Specify how to compute gradients and hessians",
         "title": "Interval Type",
         "x-model-default": "NumericalHessiansIntervalTypeForward",
         "x-union-pattern": 1
      }
   },
   "$defs": {
      "NumericalHessiansAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "NumericalHessiansAbsolute",
         "type": "object"
      },
      "NumericalHessiansBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "NumericalHessiansBounds",
         "type": "object"
      },
      "NumericalHessiansIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            }
         },
         "title": "NumericalHessiansIntervalTypeCentral",
         "type": "object"
      },
      "NumericalHessiansIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_FALSE"
                  }
               ]
            }
         },
         "title": "NumericalHessiansIntervalTypeForward",
         "type": "object"
      },
      "NumericalHessiansRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "NumericalHessiansRelative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• fd_step_size (list[float] | None)

• interval_type (dakota.spec.shared.responses.NumericalHessiansIntervalTypeForward | dakota.spec.shared.responses.NumericalHessiansIntervalTypeCentral)

• step_scaling (dakota.spec.shared.responses.NumericalHessiansRelative | dakota.spec.shared.responses.NumericalHessiansAbsolute | dakota.spec.shared.responses.NumericalHessiansBounds)

field fd_step_size: list[DakotaFloat] | None = None

Step size used when computing gradients and Hessians

field interval_type: NumericalHessiansIntervalTypeForward | NumericalHessiansIntervalTypeCentral [Optional]

Specify how to compute gradients and hessians

field step_scaling: NumericalHessiansRelative | NumericalHessiansAbsolute | NumericalHessiansBounds [Optional]

Step Scaling

pydantic model dakota.spec.shared.responses.NumericalHessiansIntervalTypeCentral

Use central differences

Show JSON schema

{
   "title": "NumericalHessiansIntervalTypeCentral",
   "description": "Use central differences",
   "type": "object",
   "properties": {
      "central": {
         "const": true,
         "default": true,
         "description": "Use central differences",
         "title": "Central",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.central_hess",
               "ir_value_type": "bool",
               "storage_type": "PRESENCE_TRUE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• central (Literal[True])

field central: Literal[True] = True

Use central differences

pydantic model dakota.spec.shared.responses.NumericalHessiansIntervalTypeForward

(Default) Use forward differences

Show JSON schema

{
   "title": "NumericalHessiansIntervalTypeForward",
   "description": "(Default) Use forward differences",
   "type": "object",
   "properties": {
      "forward": {
         "const": true,
         "default": true,
         "description": "(Default) Use forward differences",
         "title": "Forward",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.central_hess",
               "ir_value_type": "bool",
               "storage_type": "PRESENCE_FALSE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• forward (Literal[True])

field forward: Literal[True] = True

(Default) Use forward differences

pydantic model dakota.spec.shared.responses.NumericalHessiansRelative

(Default) Scale step size by the parameter value

Show JSON schema

{
   "title": "NumericalHessiansRelative",
   "description": "(Default) Scale step size by the parameter value",
   "type": "object",
   "properties": {
      "relative": {
         "const": true,
         "default": true,
         "description": "(Default) Scale step size by the parameter value",
         "title": "Relative",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.fd_hessian_step_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "relative"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• relative (Literal[True])

field relative: Literal[True] = True

(Default) Scale step size by the parameter value

pydantic model dakota.spec.shared.responses.QuasiHessians

Hessians are needed and will be approximated by secant updates (BFGS or SR1) from a series of gradient evaluations

Show JSON schema

{
   "title": "QuasiHessians",
   "description": "Hessians are needed and will be approximated by secant updates (BFGS or SR1) from a series of gradient evaluations",
   "type": "object",
   "properties": {
      "quasi_hessians": {
         "anyOf": [
            {
               "$ref": "#/$defs/QuasiHessiansBfgs"
            },
            {
               "$ref": "#/$defs/QuasiHessiansSr1"
            }
         ],
         "description": "Hessians are needed and will be approximated by secant updates (BFGS or SR1) from a series of gradient evaluations",
         "title": "Quasi Hessians",
         "x-materialization": [
            {
               "ir_key": "responses.hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "quasi"
            }
         ]
      }
   },
   "$defs": {
      "QuasiHessiansBfgs": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "bfgs": {
               "$ref": "#/$defs/QuasiHessiansBfgsConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bfgs"
                  }
               ]
            }
         },
         "required": [
            "bfgs"
         ],
         "title": "QuasiHessiansBfgs",
         "type": "object"
      },
      "QuasiHessiansBfgsConfig": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "damped": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Numerical safeguarding for BFGS updates",
               "title": "Damped",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "damped_bfgs"
                  }
               ]
            }
         },
         "title": "QuasiHessiansBfgsConfig",
         "type": "object"
      },
      "QuasiHessiansSr1": {
         "additionalProperties": false,
         "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
         "properties": {
            "sr1": {
               "const": true,
               "default": true,
               "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
               "title": "Sr1",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "sr1"
                  }
               ]
            }
         },
         "title": "QuasiHessiansSr1",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "quasi_hessians"
   ]
}

Fields:

• quasi_hessians (dakota.spec.shared.responses.QuasiHessiansBfgs | dakota.spec.shared.responses.QuasiHessiansSr1)

field quasi_hessians: QuasiHessiansBfgs | QuasiHessiansSr1 [Required]

Hessians are needed and will be approximated by secant updates (BFGS or SR1) from a series of gradient evaluations

pydantic model dakota.spec.shared.responses.QuasiHessiansBfgs

Use BFGS method to compute quasi-hessians

Show JSON schema

{
   "title": "QuasiHessiansBfgs",
   "description": "Use BFGS method to compute quasi-hessians",
   "type": "object",
   "properties": {
      "bfgs": {
         "$ref": "#/$defs/QuasiHessiansBfgsConfig",
         "x-materialization": [
            {
               "ir_key": "responses.quasi_hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "bfgs"
            }
         ]
      }
   },
   "$defs": {
      "QuasiHessiansBfgsConfig": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "damped": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Numerical safeguarding for BFGS updates",
               "title": "Damped",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "damped_bfgs"
                  }
               ]
            }
         },
         "title": "QuasiHessiansBfgsConfig",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "bfgs"
   ]
}

Fields:

• bfgs (dakota.spec.shared.responses.QuasiHessiansBfgsConfig)

field bfgs: QuasiHessiansBfgsConfig [Required]

Use BFGS method to compute quasi-hessians

pydantic model dakota.spec.shared.responses.QuasiHessiansBfgsConfig

Use BFGS method to compute quasi-hessians

Show JSON schema

{
   "title": "QuasiHessiansBfgsConfig",
   "description": "Use BFGS method to compute quasi-hessians",
   "type": "object",
   "properties": {
      "damped": {
         "anyOf": [
            {
               "const": true,
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Numerical safeguarding for BFGS updates",
         "title": "Damped",
         "x-materialization": [
            {
               "ir_key": "responses.quasi_hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "damped_bfgs"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• damped (Literal[True] | None)

field damped: Literal[True] | None = None

Numerical safeguarding for BFGS updates

pydantic model dakota.spec.shared.responses.QuasiHessiansSr1

Use the Symmetric Rank 1 update method to compute quasi-Hessians

Show JSON schema

{
   "title": "QuasiHessiansSr1",
   "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
   "type": "object",
   "properties": {
      "sr1": {
         "const": true,
         "default": true,
         "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
         "title": "Sr1",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.quasi_hessian_type",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "sr1"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• sr1 (Literal[True])

field sr1: Literal[True] = True

Use the Symmetric Rank 1 update method to compute quasi-Hessians

pydantic model dakota.spec.shared.responses.ResponseGradientsMixin

Generated model for ResponseGradientsMixin

Show JSON schema

{
   "title": "ResponseGradientsMixin",
   "description": "Generated model for ResponseGradientsMixin",
   "type": "object",
   "properties": {
      "gradient_type": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/NoGradients"
            },
            {
               "$ref": "#/$defs/AnalyticGradients"
            },
            {
               "$ref": "#/$defs/MixedGradients"
            },
            {
               "$ref": "#/$defs/NumericalGradients"
            }
         ],
         "description": "Gradient Type",
         "title": "Gradient Type",
         "x-union-pattern": 4
      }
   },
   "$defs": {
      "AnalyticGradients": {
         "additionalProperties": false,
         "description": "Analysis driver will return gradients",
         "properties": {
            "analytic_gradients": {
               "const": true,
               "default": true,
               "description": "Analysis driver will return gradients",
               "title": "Analytic Gradients",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.gradient_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "analytic"
                  }
               ]
            }
         },
         "title": "AnalyticGradients",
         "type": "object"
      },
      "MixedGradients": {
         "additionalProperties": false,
         "description": "Gradients are needed and will be obtained from a mix of numerical and analytic sources",
         "properties": {
            "mixed_gradients": {
               "$ref": "#/$defs/MixedGradientsConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.gradient_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "mixed"
                  }
               ]
            }
         },
         "required": [
            "mixed_gradients"
         ],
         "title": "MixedGradients",
         "type": "object"
      },
      "MixedGradientsConfig": {
         "additionalProperties": false,
         "description": "Gradients are needed and will be obtained from a mix of numerical and analytic sources",
         "properties": {
            "id_numerical_gradients": {
               "description": "Identify which numerical gradient corresponds to which response",
               "items": {
                  "type": "integer"
               },
               "title": "Id Numerical Gradients",
               "type": "array",
               "x-materialization": [
                  {
                     "ir_key": "responses.gradients.mixed.id_numerical",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            },
            "id_analytic_gradients": {
               "description": "Identify which analytical gradient corresponds to which response",
               "items": {
                  "type": "integer"
               },
               "title": "Id Analytic Gradients",
               "type": "array",
               "x-materialization": [
                  {
                     "ir_key": "responses.gradients.mixed.id_analytic",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            },
            "method_source": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakota"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceVendor"
                  }
               ],
               "description": "Specify which finite difference routine is used",
               "title": "Method Source",
               "x-model-default": "MixedGradientsMethodSourceDakota",
               "x-union-pattern": 1
            },
            "interval_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedGradientsIntervalTypeForward"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsIntervalTypeCentral"
                  }
               ],
               "description": "Specify how to compute gradients and hessians",
               "title": "Interval Type",
               "x-model-default": "MixedGradientsIntervalTypeForward",
               "x-union-pattern": 1
            },
            "fd_step_size": {
               "anyOf": [
                  {
                     "items": {
                        "type": "number"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Step size used when computing gradients and Hessians",
               "title": "Fd Step Size",
               "x-aliases": [
                  "fd_gradient_step_size"
               ],
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_size",
                     "ir_value_type": "RealVector",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            }
         },
         "required": [
            "id_numerical_gradients",
            "id_analytic_gradients"
         ],
         "title": "MixedGradientsConfig",
         "type": "object"
      },
      "MixedGradientsIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "central"
                  }
               ]
            }
         },
         "title": "MixedGradientsIntervalTypeCentral",
         "type": "object"
      },
      "MixedGradientsIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "forward"
                  }
               ]
            }
         },
         "title": "MixedGradientsIntervalTypeForward",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakota": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "dakota": {
               "$ref": "#/$defs/MixedGradientsMethodSourceDakotaConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "dakota"
                  }
               ],
               "x-model-default": "MixedGradientsMethodSourceDakotaConfig"
            }
         },
         "title": "MixedGradientsMethodSourceDakota",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaBounds",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaConfig": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "ignore_bounds": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Do not respect bounds when computing gradients or Hessians",
               "title": "Ignore Bounds",
               "x-materialization": [
                  {
                     "ir_key": "responses.ignore_bounds",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaRelative"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaAbsolute"
                  },
                  {
                     "$ref": "#/$defs/MixedGradientsMethodSourceDakotaBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "MixedGradientsMethodSourceDakotaRelative",
               "x-union-pattern": 1
            }
         },
         "title": "MixedGradientsMethodSourceDakotaConfig",
         "type": "object"
      },
      "MixedGradientsMethodSourceDakotaRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceDakotaRelative",
         "type": "object"
      },
      "MixedGradientsMethodSourceVendor": {
         "additionalProperties": false,
         "description": "Use non-Dakota fd algorithm",
         "properties": {
            "vendor": {
               "const": true,
               "default": true,
               "description": "Use non-Dakota fd algorithm",
               "title": "Vendor",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "vendor"
                  }
               ]
            }
         },
         "title": "MixedGradientsMethodSourceVendor",
         "type": "object"
      },
      "NoGradients": {
         "additionalProperties": false,
         "description": "Gradients will not be used",
         "properties": {
            "no_gradients": {
               "const": true,
               "default": true,
               "description": "Gradients will not be used",
               "title": "No Gradients",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.gradient_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "none"
                  }
               ]
            }
         },
         "title": "NoGradients",
         "type": "object"
      },
      "NumericalGradients": {
         "additionalProperties": false,
         "description": "Gradients are needed and will be approximated by finite differences",
         "properties": {
            "numerical_gradients": {
               "$ref": "#/$defs/NumericalGradientsConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.gradient_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "numerical"
                  }
               ]
            }
         },
         "required": [
            "numerical_gradients"
         ],
         "title": "NumericalGradients",
         "type": "object"
      },
      "NumericalGradientsConfig": {
         "additionalProperties": false,
         "description": "Gradients are needed and will be approximated by finite differences",
         "properties": {
            "method_source": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakota"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceVendor"
                  }
               ],
               "description": "Specify which finite difference routine is used",
               "title": "Method Source",
               "x-model-default": "NumericalGradientsMethodSourceDakota",
               "x-union-pattern": 1
            },
            "interval_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalGradientsIntervalTypeForward"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsIntervalTypeCentral"
                  }
               ],
               "description": "Specify how to compute gradients and hessians",
               "title": "Interval Type",
               "x-model-default": "NumericalGradientsIntervalTypeForward",
               "x-union-pattern": 1
            },
            "fd_step_size": {
               "anyOf": [
                  {
                     "items": {
                        "type": "number"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Step size used when computing gradients and Hessians",
               "title": "Fd Step Size",
               "x-aliases": [
                  "fd_gradient_step_size"
               ],
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_size",
                     "ir_value_type": "RealVector",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            }
         },
         "title": "NumericalGradientsConfig",
         "type": "object"
      },
      "NumericalGradientsIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "central"
                  }
               ]
            }
         },
         "title": "NumericalGradientsIntervalTypeCentral",
         "type": "object"
      },
      "NumericalGradientsIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.interval_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "forward"
                  }
               ]
            }
         },
         "title": "NumericalGradientsIntervalTypeForward",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakota": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "dakota": {
               "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "dakota"
                  }
               ],
               "x-model-default": "NumericalGradientsMethodSourceDakotaConfig"
            }
         },
         "title": "NumericalGradientsMethodSourceDakota",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaBounds",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaConfig": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "ignore_bounds": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Do not respect bounds when computing gradients or Hessians",
               "title": "Ignore Bounds",
               "x-materialization": [
                  {
                     "ir_key": "responses.ignore_bounds",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaRelative"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaAbsolute"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientsMethodSourceDakotaBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "NumericalGradientsMethodSourceDakotaRelative",
               "x-union-pattern": 1
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaConfig",
         "type": "object"
      },
      "NumericalGradientsMethodSourceDakotaRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_gradient_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceDakotaRelative",
         "type": "object"
      },
      "NumericalGradientsMethodSourceVendor": {
         "additionalProperties": false,
         "description": "Use non-Dakota fd algorithm",
         "properties": {
            "vendor": {
               "const": true,
               "default": true,
               "description": "Use non-Dakota fd algorithm",
               "title": "Vendor",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "vendor"
                  }
               ]
            }
         },
         "title": "NumericalGradientsMethodSourceVendor",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "gradient_type"
   ]
}

Fields:

• gradient_type (dakota.spec.shared.responses.NoGradients | dakota.spec.shared.responses.AnalyticGradients | dakota.spec.shared.responses.MixedGradients | dakota.spec.shared.responses.NumericalGradients)

field gradient_type: NoGradients | AnalyticGradients | MixedGradients | NumericalGradients [Required]

Gradient Type

pydantic model dakota.spec.shared.responses.ResponseHessiansMixin

Generated model for ResponseHessiansMixin

Show JSON schema

{
   "title": "ResponseHessiansMixin",
   "description": "Generated model for ResponseHessiansMixin",
   "type": "object",
   "properties": {
      "hessian_type": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/NoHessians"
            },
            {
               "$ref": "#/$defs/NumericalHessians"
            },
            {
               "$ref": "#/$defs/QuasiHessians"
            },
            {
               "$ref": "#/$defs/AnalyticHessians"
            },
            {
               "$ref": "#/$defs/MixedHessians"
            }
         ],
         "description": "Hessian Type",
         "title": "Hessian Type",
         "x-union-pattern": 4
      }
   },
   "$defs": {
      "AnalyticHessians": {
         "additionalProperties": false,
         "description": "Hessians are needed and are available directly from the analysis driver",
         "properties": {
            "analytic_hessians": {
               "const": true,
               "default": true,
               "description": "Hessians are needed and are available directly from the analysis driver",
               "title": "Analytic Hessians",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "analytic"
                  }
               ]
            }
         },
         "title": "AnalyticHessians",
         "type": "object"
      },
      "IdNumericalHessians": {
         "additionalProperties": false,
         "description": "Identify which numerical-Hessian corresponds to which response",
         "properties": {
            "values": {
               "description": "Identify which numerical-Hessian corresponds to which response",
               "items": {
                  "type": "integer"
               },
               "title": "Values",
               "type": "array",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessians.mixed.id_numerical",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            },
            "fd_step_size": {
               "anyOf": [
                  {
                     "items": {
                        "type": "number"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Step size used when computing gradients and Hessians",
               "title": "Fd Step Size",
               "x-aliases": [
                  "fd_hessian_step_size"
               ],
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_size",
                     "ir_value_type": "RealVector",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            }
         },
         "required": [
            "values"
         ],
         "title": "IdNumericalHessians",
         "type": "object"
      },
      "IdQuasiHessians": {
         "additionalProperties": false,
         "description": "Identify which quasi-Hessian corresponds to which response",
         "properties": {
            "values": {
               "description": "Identify which quasi-Hessian corresponds to which response",
               "items": {
                  "type": "integer"
               },
               "title": "Values",
               "type": "array",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessians.mixed.id_quasi",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            },
            "approximation": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/IdQuasiHessiansBfgs"
                  },
                  {
                     "$ref": "#/$defs/IdQuasiHessiansSr1"
                  }
               ],
               "description": "Quasi-Hessian Approximation",
               "title": "Approximation",
               "x-union-pattern": 4
            }
         },
         "required": [
            "values",
            "approximation"
         ],
         "title": "IdQuasiHessians",
         "type": "object"
      },
      "IdQuasiHessiansBfgs": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "bfgs": {
               "$ref": "#/$defs/IdQuasiHessiansBfgsConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bfgs"
                  }
               ]
            }
         },
         "required": [
            "bfgs"
         ],
         "title": "IdQuasiHessiansBfgs",
         "type": "object"
      },
      "IdQuasiHessiansBfgsConfig": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "damped": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Numerical safeguarding for BFGS updates",
               "title": "Damped",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "damped_bfgs"
                  }
               ]
            }
         },
         "title": "IdQuasiHessiansBfgsConfig",
         "type": "object"
      },
      "IdQuasiHessiansSr1": {
         "additionalProperties": false,
         "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
         "properties": {
            "sr1": {
               "const": true,
               "default": true,
               "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
               "title": "Sr1",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "sr1"
                  }
               ]
            }
         },
         "title": "IdQuasiHessiansSr1",
         "type": "object"
      },
      "MixedHessians": {
         "additionalProperties": false,
         "description": "Hessians are needed and will be obtained from a mix of numerical, analytic, and \\\"quasi\\\" sources",
         "properties": {
            "mixed_hessians": {
               "$ref": "#/$defs/MixedHessiansConfig",
               "description": "Hessians are needed and will be obtained from a mix of numerical, analytic, and \"quasi\" sources",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "mixed"
                  }
               ]
            }
         },
         "required": [
            "mixed_hessians"
         ],
         "title": "MixedHessians",
         "type": "object"
      },
      "MixedHessiansAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "MixedHessiansAbsolute",
         "type": "object"
      },
      "MixedHessiansBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "MixedHessiansBounds",
         "type": "object"
      },
      "MixedHessiansConfig": {
         "additionalProperties": false,
         "description": "Hessians are needed and will be obtained from a mix of numerical, analytic, and \\\"quasi\\\" sources",
         "properties": {
            "id_numerical_hessians": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/IdNumericalHessians"
                  },
                  {
                     "type": "null"
                  }
               ],
               "argument": "values",
               "default": null,
               "description": "Identify which numerical-Hessian corresponds to which response"
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedHessiansRelative"
                  },
                  {
                     "$ref": "#/$defs/MixedHessiansAbsolute"
                  },
                  {
                     "$ref": "#/$defs/MixedHessiansBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "MixedHessiansRelative",
               "x-union-pattern": 1
            },
            "interval_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/MixedHessiansIntervalTypeForward"
                  },
                  {
                     "$ref": "#/$defs/MixedHessiansIntervalTypeCentral"
                  }
               ],
               "description": "Specify how to compute gradients and hessians",
               "title": "Interval Type",
               "x-model-default": "MixedHessiansIntervalTypeForward",
               "x-union-pattern": 1
            },
            "id_quasi_hessians": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/IdQuasiHessians"
                  },
                  {
                     "type": "null"
                  }
               ],
               "argument": "values",
               "default": null,
               "description": "Identify which quasi-Hessian corresponds to which response"
            },
            "id_analytic_hessians": {
               "anyOf": [
                  {
                     "items": {
                        "type": "integer"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Identify which analytical Hessian corresponds to which response",
               "title": "Id Analytic Hessians",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessians.mixed.id_analytic",
                     "ir_value_type": "IntSet",
                     "storage_type": "INT_SET"
                  }
               ]
            }
         },
         "title": "MixedHessiansConfig",
         "type": "object"
      },
      "MixedHessiansIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            }
         },
         "title": "MixedHessiansIntervalTypeCentral",
         "type": "object"
      },
      "MixedHessiansIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_FALSE"
                  }
               ]
            }
         },
         "title": "MixedHessiansIntervalTypeForward",
         "type": "object"
      },
      "MixedHessiansRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "MixedHessiansRelative",
         "type": "object"
      },
      "NoHessians": {
         "additionalProperties": false,
         "description": "Hessians will not be used",
         "properties": {
            "no_hessians": {
               "const": true,
               "default": true,
               "description": "Hessians will not be used",
               "title": "No Hessians",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "none"
                  }
               ]
            }
         },
         "title": "NoHessians",
         "type": "object"
      },
      "NumericalHessians": {
         "additionalProperties": false,
         "description": "Hessians are needed and will be approximated by finite differences",
         "properties": {
            "numerical_hessians": {
               "$ref": "#/$defs/NumericalHessiansConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "numerical"
                  }
               ]
            }
         },
         "required": [
            "numerical_hessians"
         ],
         "title": "NumericalHessians",
         "type": "object"
      },
      "NumericalHessiansAbsolute": {
         "additionalProperties": false,
         "description": "Do not scale step-size",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Do not scale step-size",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "absolute"
                  }
               ]
            }
         },
         "title": "NumericalHessiansAbsolute",
         "type": "object"
      },
      "NumericalHessiansBounds": {
         "additionalProperties": false,
         "description": "Scale step-size by the domain of the parameter",
         "properties": {
            "bounds": {
               "const": true,
               "default": true,
               "description": "Scale step-size by the domain of the parameter",
               "title": "Bounds",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bounds"
                  }
               ]
            }
         },
         "title": "NumericalHessiansBounds",
         "type": "object"
      },
      "NumericalHessiansConfig": {
         "additionalProperties": false,
         "description": "Hessians are needed and will be approximated by finite differences",
         "properties": {
            "fd_step_size": {
               "anyOf": [
                  {
                     "items": {
                        "type": "number"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Step size used when computing gradients and Hessians",
               "title": "Fd Step Size",
               "x-aliases": [
                  "fd_hessian_step_size"
               ],
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_size",
                     "ir_value_type": "RealVector",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            },
            "step_scaling": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalHessiansRelative"
                  },
                  {
                     "$ref": "#/$defs/NumericalHessiansAbsolute"
                  },
                  {
                     "$ref": "#/$defs/NumericalHessiansBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "NumericalHessiansRelative",
               "x-union-pattern": 1
            },
            "interval_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/NumericalHessiansIntervalTypeForward"
                  },
                  {
                     "$ref": "#/$defs/NumericalHessiansIntervalTypeCentral"
                  }
               ],
               "description": "Specify how to compute gradients and hessians",
               "title": "Interval Type",
               "x-model-default": "NumericalHessiansIntervalTypeForward",
               "x-union-pattern": 1
            }
         },
         "title": "NumericalHessiansConfig",
         "type": "object"
      },
      "NumericalHessiansIntervalTypeCentral": {
         "additionalProperties": false,
         "description": "Use central differences",
         "properties": {
            "central": {
               "const": true,
               "default": true,
               "description": "Use central differences",
               "title": "Central",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_TRUE"
                  }
               ]
            }
         },
         "title": "NumericalHessiansIntervalTypeCentral",
         "type": "object"
      },
      "NumericalHessiansIntervalTypeForward": {
         "additionalProperties": false,
         "description": "(Default) Use forward differences",
         "properties": {
            "forward": {
               "const": true,
               "default": true,
               "description": "(Default) Use forward differences",
               "title": "Forward",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.central_hess",
                     "ir_value_type": "bool",
                     "storage_type": "PRESENCE_FALSE"
                  }
               ]
            }
         },
         "title": "NumericalHessiansIntervalTypeForward",
         "type": "object"
      },
      "NumericalHessiansRelative": {
         "additionalProperties": false,
         "description": "(Default) Scale step size by the parameter value",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "(Default) Scale step size by the parameter value",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.fd_hessian_step_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "relative"
                  }
               ]
            }
         },
         "title": "NumericalHessiansRelative",
         "type": "object"
      },
      "QuasiHessians": {
         "additionalProperties": false,
         "description": "Hessians are needed and will be approximated by secant updates (BFGS or SR1) from a series of gradient evaluations",
         "properties": {
            "quasi_hessians": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/QuasiHessiansBfgs"
                  },
                  {
                     "$ref": "#/$defs/QuasiHessiansSr1"
                  }
               ],
               "description": "Hessians are needed and will be approximated by secant updates (BFGS or SR1) from a series of gradient evaluations",
               "title": "Quasi Hessians",
               "x-materialization": [
                  {
                     "ir_key": "responses.hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "quasi"
                  }
               ]
            }
         },
         "required": [
            "quasi_hessians"
         ],
         "title": "QuasiHessians",
         "type": "object"
      },
      "QuasiHessiansBfgs": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "bfgs": {
               "$ref": "#/$defs/QuasiHessiansBfgsConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "bfgs"
                  }
               ]
            }
         },
         "required": [
            "bfgs"
         ],
         "title": "QuasiHessiansBfgs",
         "type": "object"
      },
      "QuasiHessiansBfgsConfig": {
         "additionalProperties": false,
         "description": "Use BFGS method to compute quasi-hessians",
         "properties": {
            "damped": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Numerical safeguarding for BFGS updates",
               "title": "Damped",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "damped_bfgs"
                  }
               ]
            }
         },
         "title": "QuasiHessiansBfgsConfig",
         "type": "object"
      },
      "QuasiHessiansSr1": {
         "additionalProperties": false,
         "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
         "properties": {
            "sr1": {
               "const": true,
               "default": true,
               "description": "Use the Symmetric Rank 1 update method to compute quasi-Hessians",
               "title": "Sr1",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.quasi_hessian_type",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "sr1"
                  }
               ]
            }
         },
         "title": "QuasiHessiansSr1",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "hessian_type"
   ]
}

Fields:

• hessian_type (dakota.spec.shared.responses.NoHessians | dakota.spec.shared.responses.NumericalHessians | dakota.spec.shared.responses.QuasiHessians | dakota.spec.shared.responses.AnalyticHessians | dakota.spec.shared.responses.MixedHessians)

field hessian_type: NoHessians | NumericalHessians | QuasiHessians | AnalyticHessians | MixedHessians [Required]

Hessian Type

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1Compute

Selection of statistics to compute at each response level

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext1Compute",
   "description": "Selection of statistics to compute at each response level",
   "type": "object",
   "properties": {
      "statistic": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1Probabilities"
            },
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1GenReliabilities"
            }
         ],
         "description": "Statistics to Compute",
         "title": "Statistic",
         "x-union-pattern": 4
      },
      "system": {
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1SystemSeries"
            },
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1SystemParallel"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Compute system reliability (series or parallel)",
         "title": "System",
         "x-union-pattern": 2
      }
   },
   "$defs": {
      "ResponseLevelsComputeProbGenContext1GenReliabilities": {
         "additionalProperties": false,
         "description": "Computes generalized reliabilities associated with response levels",
         "properties": {
            "gen_reliabilities": {
               "const": true,
               "default": true,
               "description": "Computes generalized reliabilities associated with response levels",
               "title": "Gen Reliabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "GEN_RELIABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1GenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1Probabilities": {
         "additionalProperties": false,
         "description": "Computes probabilities associated with response levels",
         "properties": {
            "probabilities": {
               "const": true,
               "default": true,
               "description": "Computes probabilities associated with response levels",
               "title": "Probabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "PROBABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1Probabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1SystemParallel": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a parallel system",
         "properties": {
            "parallel": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a parallel system",
               "title": "Parallel",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_PARALLEL"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1SystemParallel",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1SystemSeries": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a series system",
         "properties": {
            "series": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a series system",
               "title": "Series",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_SERIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1SystemSeries",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "statistic"
   ]
}

Fields:

• statistic (dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1Probabilities | dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1GenReliabilities)

• system (dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1SystemSeries | dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1SystemParallel | None)

field statistic: ResponseLevelsComputeProbGenContext1Probabilities | ResponseLevelsComputeProbGenContext1GenReliabilities [Required]

Statistics to Compute

field system: ResponseLevelsComputeProbGenContext1SystemSeries | ResponseLevelsComputeProbGenContext1SystemParallel | None = None

Compute system reliability (series or parallel)

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1GenReliabilities

Computes generalized reliabilities associated with response levels

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext1GenReliabilities",
   "description": "Computes generalized reliabilities associated with response levels",
   "type": "object",
   "properties": {
      "gen_reliabilities": {
         "const": true,
         "default": true,
         "description": "Computes generalized reliabilities associated with response levels",
         "title": "Gen Reliabilities",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_level_target",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "GEN_RELIABILITIES"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• gen_reliabilities (Literal[True])

field gen_reliabilities: Literal[True] = True

Computes generalized reliabilities associated with response levels

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1Mixin

Generated model for ResponseLevelsComputeProbGenContext1Mixin

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext1Mixin",
   "description": "Generated model for ResponseLevelsComputeProbGenContext1Mixin",
   "type": "object",
   "properties": {
      "response_levels": {
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1ResponseLevels"
            },
            {
               "type": "null"
            }
         ],
         "argument": "values",
         "default": null,
         "description": "Values at which to estimate desired statistics for each response",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_levels",
               "ir_value_type": "RealVectorArray",
               "storage_type": "RESPONSE_LEVELS_ARRAY"
            }
         ]
      }
   },
   "$defs": {
      "ResponseLevelsComputeProbGenContext1Compute": {
         "additionalProperties": false,
         "description": "Selection of statistics to compute at each response level",
         "properties": {
            "statistic": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1Probabilities"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1GenReliabilities"
                  }
               ],
               "description": "Statistics to Compute",
               "title": "Statistic",
               "x-union-pattern": 4
            },
            "system": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1SystemSeries"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1SystemParallel"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Compute system reliability (series or parallel)",
               "title": "System",
               "x-union-pattern": 2
            }
         },
         "required": [
            "statistic"
         ],
         "title": "ResponseLevelsComputeProbGenContext1Compute",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1GenReliabilities": {
         "additionalProperties": false,
         "description": "Computes generalized reliabilities associated with response levels",
         "properties": {
            "gen_reliabilities": {
               "const": true,
               "default": true,
               "description": "Computes generalized reliabilities associated with response levels",
               "title": "Gen Reliabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "GEN_RELIABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1GenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1Probabilities": {
         "additionalProperties": false,
         "description": "Computes probabilities associated with response levels",
         "properties": {
            "probabilities": {
               "const": true,
               "default": true,
               "description": "Computes probabilities associated with response levels",
               "title": "Probabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "PROBABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1Probabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1ResponseLevels": {
         "additionalProperties": false,
         "description": "Values at which to estimate desired statistics for each response",
         "properties": {
            "values": {
               "description": "Values at which to estimate desired statistics for each response",
               "items": {
                  "type": "number"
               },
               "title": "Values",
               "type": "array"
            },
            "num_response_levels": {
               "anyOf": [
                  {
                     "items": {
                        "type": "integer"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Number of values at which to estimate desired statistics for each response",
               "title": "Num Response Levels"
            },
            "compute": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1Compute"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Selection of statistics to compute at each response level"
            }
         },
         "required": [
            "values"
         ],
         "title": "ResponseLevelsComputeProbGenContext1ResponseLevels",
         "type": "object",
         "x-model-validations": [
            {
               "validationContext": "responselevelscomputeprobgencontext1responselevels",
               "validationErrorMessage": "For responselevelscomputeprobgencontext1responselevels, sum of num_response_levels must equal length of values.",
               "validationFields": [
                  "num_response_levels",
                  "values"
               ],
               "validationLiterals": [],
               "validationRuleName": "check_sum_equals_length"
            }
         ]
      },
      "ResponseLevelsComputeProbGenContext1SystemParallel": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a parallel system",
         "properties": {
            "parallel": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a parallel system",
               "title": "Parallel",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_PARALLEL"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1SystemParallel",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1SystemSeries": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a series system",
         "properties": {
            "series": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a series system",
               "title": "Series",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_SERIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1SystemSeries",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• response_levels (dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1ResponseLevels | None)

field response_levels: ResponseLevelsComputeProbGenContext1ResponseLevels | None = None

Values at which to estimate desired statistics for each response

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1Probabilities

Computes probabilities associated with response levels

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext1Probabilities",
   "description": "Computes probabilities associated with response levels",
   "type": "object",
   "properties": {
      "probabilities": {
         "const": true,
         "default": true,
         "description": "Computes probabilities associated with response levels",
         "title": "Probabilities",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_level_target",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "PROBABILITIES"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• probabilities (Literal[True])

field probabilities: Literal[True] = True

Computes probabilities associated with response levels

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1ResponseLevels

Values at which to estimate desired statistics for each response

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext1ResponseLevels",
   "description": "Values at which to estimate desired statistics for each response",
   "type": "object",
   "properties": {
      "values": {
         "description": "Values at which to estimate desired statistics for each response",
         "items": {
            "type": "number"
         },
         "title": "Values",
         "type": "array"
      },
      "num_response_levels": {
         "anyOf": [
            {
               "items": {
                  "type": "integer"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Number of values at which to estimate desired statistics for each response",
         "title": "Num Response Levels"
      },
      "compute": {
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1Compute"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Selection of statistics to compute at each response level"
      }
   },
   "$defs": {
      "ResponseLevelsComputeProbGenContext1Compute": {
         "additionalProperties": false,
         "description": "Selection of statistics to compute at each response level",
         "properties": {
            "statistic": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1Probabilities"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1GenReliabilities"
                  }
               ],
               "description": "Statistics to Compute",
               "title": "Statistic",
               "x-union-pattern": 4
            },
            "system": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1SystemSeries"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext1SystemParallel"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Compute system reliability (series or parallel)",
               "title": "System",
               "x-union-pattern": 2
            }
         },
         "required": [
            "statistic"
         ],
         "title": "ResponseLevelsComputeProbGenContext1Compute",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1GenReliabilities": {
         "additionalProperties": false,
         "description": "Computes generalized reliabilities associated with response levels",
         "properties": {
            "gen_reliabilities": {
               "const": true,
               "default": true,
               "description": "Computes generalized reliabilities associated with response levels",
               "title": "Gen Reliabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "GEN_RELIABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1GenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1Probabilities": {
         "additionalProperties": false,
         "description": "Computes probabilities associated with response levels",
         "properties": {
            "probabilities": {
               "const": true,
               "default": true,
               "description": "Computes probabilities associated with response levels",
               "title": "Probabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "PROBABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1Probabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1SystemParallel": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a parallel system",
         "properties": {
            "parallel": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a parallel system",
               "title": "Parallel",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_PARALLEL"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1SystemParallel",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext1SystemSeries": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a series system",
         "properties": {
            "series": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a series system",
               "title": "Series",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_SERIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext1SystemSeries",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "values"
   ],
   "x-model-validations": [
      {
         "validationContext": "responselevelscomputeprobgencontext1responselevels",
         "validationErrorMessage": "For responselevelscomputeprobgencontext1responselevels, sum of num_response_levels must equal length of values.",
         "validationFields": [
            "num_response_levels",
            "values"
         ],
         "validationLiterals": [],
         "validationRuleName": "check_sum_equals_length"
      }
   ]
}

Fields:

• compute (dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1Compute | None)

• num_response_levels (list[int] | None)

• values (list[float])

field compute: ResponseLevelsComputeProbGenContext1Compute | None = None

Selection of statistics to compute at each response level

field num_response_levels: list[int] | None = None

Number of values at which to estimate desired statistics for each response

field values: list[DakotaFloat] [Required]

Values at which to estimate desired statistics for each response

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1SystemParallel

Aggregate response statistics assuming a parallel system

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext1SystemParallel",
   "description": "Aggregate response statistics assuming a parallel system",
   "type": "object",
   "properties": {
      "parallel": {
         "const": true,
         "default": true,
         "description": "Aggregate response statistics assuming a parallel system",
         "title": "Parallel",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_level_target_reduce",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "SYSTEM_PARALLEL"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• parallel (Literal[True])

field parallel: Literal[True] = True

Aggregate response statistics assuming a parallel system

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext1SystemSeries

Aggregate response statistics assuming a series system

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext1SystemSeries",
   "description": "Aggregate response statistics assuming a series system",
   "type": "object",
   "properties": {
      "series": {
         "const": true,
         "default": true,
         "description": "Aggregate response statistics assuming a series system",
         "title": "Series",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_level_target_reduce",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "SYSTEM_SERIES"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• series (Literal[True])

field series: Literal[True] = True

Aggregate response statistics assuming a series system

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2Compute

Selection of statistics to compute at each response level

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext2Compute",
   "description": "Selection of statistics to compute at each response level",
   "type": "object",
   "properties": {
      "statistic": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2Probabilities"
            },
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2GenReliabilities"
            }
         ],
         "description": "Statistics to Compute",
         "title": "Statistic",
         "x-union-pattern": 4
      },
      "system": {
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2SystemSeries"
            },
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2SystemParallel"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Compute system reliability (series or parallel)",
         "title": "System",
         "x-union-pattern": 2
      }
   },
   "$defs": {
      "ResponseLevelsComputeProbGenContext2GenReliabilities": {
         "additionalProperties": false,
         "description": "Computes generalized reliabilities associated with response levels",
         "properties": {
            "gen_reliabilities": {
               "const": true,
               "default": true,
               "description": "Computes generalized reliabilities associated with response levels",
               "title": "Gen Reliabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "GEN_RELIABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2GenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2Probabilities": {
         "additionalProperties": false,
         "description": "Computes probabilities associated with response levels",
         "properties": {
            "probabilities": {
               "const": true,
               "default": true,
               "description": "Computes probabilities associated with response levels",
               "title": "Probabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "PROBABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2Probabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2SystemParallel": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a parallel system",
         "properties": {
            "parallel": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a parallel system",
               "title": "Parallel",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_PARALLEL"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2SystemParallel",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2SystemSeries": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a series system",
         "properties": {
            "series": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a series system",
               "title": "Series",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_SERIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2SystemSeries",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "statistic"
   ]
}

Fields:

• statistic (dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2Probabilities | dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2GenReliabilities)

• system (dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2SystemSeries | dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2SystemParallel | None)

field statistic: ResponseLevelsComputeProbGenContext2Probabilities | ResponseLevelsComputeProbGenContext2GenReliabilities [Required]

Statistics to Compute

field system: ResponseLevelsComputeProbGenContext2SystemSeries | ResponseLevelsComputeProbGenContext2SystemParallel | None = None

Compute system reliability (series or parallel)

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2GenReliabilities

Computes generalized reliabilities associated with response levels

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext2GenReliabilities",
   "description": "Computes generalized reliabilities associated with response levels",
   "type": "object",
   "properties": {
      "gen_reliabilities": {
         "const": true,
         "default": true,
         "description": "Computes generalized reliabilities associated with response levels",
         "title": "Gen Reliabilities",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_level_target",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "GEN_RELIABILITIES"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• gen_reliabilities (Literal[True])

field gen_reliabilities: Literal[True] = True

Computes generalized reliabilities associated with response levels

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2Mixin

Generated model for ResponseLevelsComputeProbGenContext2Mixin

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext2Mixin",
   "description": "Generated model for ResponseLevelsComputeProbGenContext2Mixin",
   "type": "object",
   "properties": {
      "response_levels": {
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2ResponseLevels"
            },
            {
               "type": "null"
            }
         ],
         "argument": "values",
         "default": null,
         "description": "Undocumented: Recursive k-d (RKD) Darts is an experimental capability.",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_levels",
               "ir_value_type": "RealVectorArray",
               "storage_type": "RESPONSE_LEVELS_ARRAY"
            }
         ]
      }
   },
   "$defs": {
      "ResponseLevelsComputeProbGenContext2Compute": {
         "additionalProperties": false,
         "description": "Selection of statistics to compute at each response level",
         "properties": {
            "statistic": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2Probabilities"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2GenReliabilities"
                  }
               ],
               "description": "Statistics to Compute",
               "title": "Statistic",
               "x-union-pattern": 4
            },
            "system": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2SystemSeries"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2SystemParallel"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Compute system reliability (series or parallel)",
               "title": "System",
               "x-union-pattern": 2
            }
         },
         "required": [
            "statistic"
         ],
         "title": "ResponseLevelsComputeProbGenContext2Compute",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2GenReliabilities": {
         "additionalProperties": false,
         "description": "Computes generalized reliabilities associated with response levels",
         "properties": {
            "gen_reliabilities": {
               "const": true,
               "default": true,
               "description": "Computes generalized reliabilities associated with response levels",
               "title": "Gen Reliabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "GEN_RELIABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2GenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2Probabilities": {
         "additionalProperties": false,
         "description": "Computes probabilities associated with response levels",
         "properties": {
            "probabilities": {
               "const": true,
               "default": true,
               "description": "Computes probabilities associated with response levels",
               "title": "Probabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "PROBABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2Probabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2ResponseLevels": {
         "additionalProperties": false,
         "description": "Undocumented: Recursive k-d (RKD) Darts is an experimental capability.",
         "properties": {
            "values": {
               "description": "Undocumented: Recursive k-d (RKD) Darts is an experimental capability.",
               "items": {
                  "type": "number"
               },
               "title": "Values",
               "type": "array"
            },
            "num_response_levels": {
               "anyOf": [
                  {
                     "items": {
                        "type": "integer"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Number of values at which to estimate desired statistics for each response",
               "title": "Num Response Levels"
            },
            "compute": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2Compute"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Selection of statistics to compute at each response level"
            }
         },
         "required": [
            "values"
         ],
         "title": "ResponseLevelsComputeProbGenContext2ResponseLevels",
         "type": "object",
         "x-model-validations": [
            {
               "validationContext": "responselevelscomputeprobgencontext2responselevels",
               "validationErrorMessage": "For responselevelscomputeprobgencontext2responselevels, sum of num_response_levels must equal length of values.",
               "validationFields": [
                  "num_response_levels",
                  "values"
               ],
               "validationLiterals": [],
               "validationRuleName": "check_sum_equals_length"
            }
         ]
      },
      "ResponseLevelsComputeProbGenContext2SystemParallel": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a parallel system",
         "properties": {
            "parallel": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a parallel system",
               "title": "Parallel",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_PARALLEL"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2SystemParallel",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2SystemSeries": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a series system",
         "properties": {
            "series": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a series system",
               "title": "Series",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_SERIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2SystemSeries",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• response_levels (dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2ResponseLevels | None)

field response_levels: ResponseLevelsComputeProbGenContext2ResponseLevels | None = None

Undocumented: Recursive k-d (RKD) Darts is an experimental capability.

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2Probabilities

Computes probabilities associated with response levels

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext2Probabilities",
   "description": "Computes probabilities associated with response levels",
   "type": "object",
   "properties": {
      "probabilities": {
         "const": true,
         "default": true,
         "description": "Computes probabilities associated with response levels",
         "title": "Probabilities",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_level_target",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "PROBABILITIES"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• probabilities (Literal[True])

field probabilities: Literal[True] = True

Computes probabilities associated with response levels

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2ResponseLevels

Undocumented: Recursive k-d (RKD) Darts is an experimental capability.

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext2ResponseLevels",
   "description": "Undocumented: Recursive k-d (RKD) Darts is an experimental capability.",
   "type": "object",
   "properties": {
      "values": {
         "description": "Undocumented: Recursive k-d (RKD) Darts is an experimental capability.",
         "items": {
            "type": "number"
         },
         "title": "Values",
         "type": "array"
      },
      "num_response_levels": {
         "anyOf": [
            {
               "items": {
                  "type": "integer"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Number of values at which to estimate desired statistics for each response",
         "title": "Num Response Levels"
      },
      "compute": {
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2Compute"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Selection of statistics to compute at each response level"
      }
   },
   "$defs": {
      "ResponseLevelsComputeProbGenContext2Compute": {
         "additionalProperties": false,
         "description": "Selection of statistics to compute at each response level",
         "properties": {
            "statistic": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2Probabilities"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2GenReliabilities"
                  }
               ],
               "description": "Statistics to Compute",
               "title": "Statistic",
               "x-union-pattern": 4
            },
            "system": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2SystemSeries"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbGenContext2SystemParallel"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Compute system reliability (series or parallel)",
               "title": "System",
               "x-union-pattern": 2
            }
         },
         "required": [
            "statistic"
         ],
         "title": "ResponseLevelsComputeProbGenContext2Compute",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2GenReliabilities": {
         "additionalProperties": false,
         "description": "Computes generalized reliabilities associated with response levels",
         "properties": {
            "gen_reliabilities": {
               "const": true,
               "default": true,
               "description": "Computes generalized reliabilities associated with response levels",
               "title": "Gen Reliabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "GEN_RELIABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2GenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2Probabilities": {
         "additionalProperties": false,
         "description": "Computes probabilities associated with response levels",
         "properties": {
            "probabilities": {
               "const": true,
               "default": true,
               "description": "Computes probabilities associated with response levels",
               "title": "Probabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "PROBABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2Probabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2SystemParallel": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a parallel system",
         "properties": {
            "parallel": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a parallel system",
               "title": "Parallel",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_PARALLEL"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2SystemParallel",
         "type": "object"
      },
      "ResponseLevelsComputeProbGenContext2SystemSeries": {
         "additionalProperties": false,
         "description": "Aggregate response statistics assuming a series system",
         "properties": {
            "series": {
               "const": true,
               "default": true,
               "description": "Aggregate response statistics assuming a series system",
               "title": "Series",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target_reduce",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "SYSTEM_SERIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbGenContext2SystemSeries",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "values"
   ],
   "x-model-validations": [
      {
         "validationContext": "responselevelscomputeprobgencontext2responselevels",
         "validationErrorMessage": "For responselevelscomputeprobgencontext2responselevels, sum of num_response_levels must equal length of values.",
         "validationFields": [
            "num_response_levels",
            "values"
         ],
         "validationLiterals": [],
         "validationRuleName": "check_sum_equals_length"
      }
   ]
}

Fields:

• compute (dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2Compute | None)

• num_response_levels (list[int] | None)

• values (list[float])

field compute: ResponseLevelsComputeProbGenContext2Compute | None = None

Selection of statistics to compute at each response level

field num_response_levels: list[int] | None = None

Number of values at which to estimate desired statistics for each response

field values: list[DakotaFloat] [Required]

Undocumented: Recursive k-d (RKD) Darts is an experimental capability.

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2SystemParallel

Aggregate response statistics assuming a parallel system

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext2SystemParallel",
   "description": "Aggregate response statistics assuming a parallel system",
   "type": "object",
   "properties": {
      "parallel": {
         "const": true,
         "default": true,
         "description": "Aggregate response statistics assuming a parallel system",
         "title": "Parallel",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_level_target_reduce",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "SYSTEM_PARALLEL"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• parallel (Literal[True])

field parallel: Literal[True] = True

Aggregate response statistics assuming a parallel system

pydantic model dakota.spec.shared.responses.ResponseLevelsComputeProbGenContext2SystemSeries

Aggregate response statistics assuming a series system

Show JSON schema

{
   "title": "ResponseLevelsComputeProbGenContext2SystemSeries",
   "description": "Aggregate response statistics assuming a series system",
   "type": "object",
   "properties": {
      "series": {
         "const": true,
         "default": true,
         "description": "Aggregate response statistics assuming a series system",
         "title": "Series",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_level_target_reduce",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "SYSTEM_SERIES"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• series (Literal[True])

field series: Literal[True] = True

Aggregate response statistics assuming a series system

pydantic model dakota.spec.shared.responses.ResponseScalarDataFormatAnnotated

Selects annotated tabular file format for experiment data

Show JSON schema

{
   "title": "ResponseScalarDataFormatAnnotated",
   "description": "Selects annotated tabular file format for experiment data",
   "type": "object",
   "properties": {
      "annotated": {
         "const": true,
         "default": true,
         "description": "Selects annotated tabular file format for experiment data",
         "title": "Annotated",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.scalar_data_format",
               "ir_value_type": "unsigned short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "TABULAR_EXPER_ANNOT"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• annotated (Literal[True])

field annotated: Literal[True] = True

Selects annotated tabular file format for experiment data

pydantic model dakota.spec.shared.responses.ResponseScalarDataFormatCustomAnnotated

Selects custom-annotated tabular file format for experiment data

Show JSON schema

{
   "title": "ResponseScalarDataFormatCustomAnnotated",
   "description": "Selects custom-annotated tabular file format for experiment data",
   "type": "object",
   "properties": {
      "custom_annotated": {
         "$ref": "#/$defs/ResponseScalarDataFormatCustomAnnotatedConfig",
         "x-materialization": [
            {
               "ir_key": "responses.scalar_data_format",
               "ir_value_type": "unsigned short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "TABULAR_NONE"
            }
         ],
         "x-model-default": "ResponseScalarDataFormatCustomAnnotatedConfig"
      }
   },
   "$defs": {
      "ResponseScalarDataFormatCustomAnnotatedConfig": {
         "additionalProperties": false,
         "description": "Selects custom-annotated tabular file format for experiment data",
         "properties": {
            "header": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Enable header row in custom-annotated tabular file",
               "title": "Header",
               "x-materialization": [
                  {
                     "ir_key": "responses.scalar_data_format",
                     "ir_value_type": "unsigned short",
                     "storage_type": "AUGMENT_ENUM",
                     "stored_value": "TABULAR_HEADER"
                  }
               ]
            },
            "exp_id": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Enable experiment ID column in custom-annotated tabular file",
               "title": "Exp Id",
               "x-materialization": [
                  {
                     "ir_key": "responses.scalar_data_format",
                     "ir_value_type": "unsigned short",
                     "storage_type": "AUGMENT_ENUM",
                     "stored_value": "TABULAR_EVAL_ID"
                  }
               ]
            }
         },
         "title": "ResponseScalarDataFormatCustomAnnotatedConfig",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• custom_annotated (dakota.spec.shared.responses.ResponseScalarDataFormatCustomAnnotatedConfig)

field custom_annotated: ResponseScalarDataFormatCustomAnnotatedConfig [Optional]

Selects custom-annotated tabular file format for experiment data

pydantic model dakota.spec.shared.responses.ResponseScalarDataFormatCustomAnnotatedConfig

Selects custom-annotated tabular file format for experiment data

Show JSON schema

{
   "title": "ResponseScalarDataFormatCustomAnnotatedConfig",
   "description": "Selects custom-annotated tabular file format for experiment data",
   "type": "object",
   "properties": {
      "header": {
         "anyOf": [
            {
               "const": true,
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Enable header row in custom-annotated tabular file",
         "title": "Header",
         "x-materialization": [
            {
               "ir_key": "responses.scalar_data_format",
               "ir_value_type": "unsigned short",
               "storage_type": "AUGMENT_ENUM",
               "stored_value": "TABULAR_HEADER"
            }
         ]
      },
      "exp_id": {
         "anyOf": [
            {
               "const": true,
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Enable experiment ID column in custom-annotated tabular file",
         "title": "Exp Id",
         "x-materialization": [
            {
               "ir_key": "responses.scalar_data_format",
               "ir_value_type": "unsigned short",
               "storage_type": "AUGMENT_ENUM",
               "stored_value": "TABULAR_EVAL_ID"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• exp_id (Literal[True] | None)

• header (Literal[True] | None)

field exp_id: Literal[True] | None = None

Enable experiment ID column in custom-annotated tabular file

field header: Literal[True] | None = None

Enable header row in custom-annotated tabular file

pydantic model dakota.spec.shared.responses.ResponseScalarDataFormatFreeform

Selects free-form tabular file format for experiment data

Show JSON schema

{
   "title": "ResponseScalarDataFormatFreeform",
   "description": "Selects free-form tabular file format for experiment data",
   "type": "object",
   "properties": {
      "freeform": {
         "const": true,
         "default": true,
         "description": "Selects free-form tabular file format for experiment data",
         "title": "Freeform",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "responses.scalar_data_format",
               "ir_value_type": "unsigned short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "TABULAR_NONE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:

• freeform (Literal[True])

field freeform: Literal[True] = True

Selects free-form tabular file format for experiment data

pydantic model dakota.spec.shared.responses.ResponseScalarDataFormatMixin

Generated model for ResponseScalarDataFormatMixin

Show JSON schema

{
   "title": "ResponseScalarDataFormatMixin",
   "description": "Generated model for ResponseScalarDataFormatMixin",
   "type": "object",
   "properties": {
      "format": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseScalarDataFormatCustomAnnotated"
            },
            {
               "$ref": "#/$defs/ResponseScalarDataFormatAnnotated"
            },
            {
               "$ref": "#/$defs/ResponseScalarDataFormatFreeform"
            }
         ],
         "description": "Tabular Format",
         "title": "Format",
         "x-model-default": "ResponseScalarDataFormatAnnotated",
         "x-union-pattern": 1
      }
   },
   "$defs": {
      "ResponseScalarDataFormatAnnotated": {
         "additionalProperties": false,
         "description": "Selects annotated tabular file format for experiment data",
         "properties": {
            "annotated": {
               "const": true,
               "default": true,
               "description": "Selects annotated tabular file format for experiment data",
               "title": "Annotated",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.scalar_data_format",
                     "ir_value_type": "unsigned short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "TABULAR_EXPER_ANNOT"
                  }
               ]
            }
         },
         "title": "ResponseScalarDataFormatAnnotated",
         "type": "object"
      },
      "ResponseScalarDataFormatCustomAnnotated": {
         "additionalProperties": false,
         "description": "Selects custom-annotated tabular file format for experiment data",
         "properties": {
            "custom_annotated": {
               "$ref": "#/$defs/ResponseScalarDataFormatCustomAnnotatedConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.scalar_data_format",
                     "ir_value_type": "unsigned short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "TABULAR_NONE"
                  }
               ],
               "x-model-default": "ResponseScalarDataFormatCustomAnnotatedConfig"
            }
         },
         "title": "ResponseScalarDataFormatCustomAnnotated",
         "type": "object"
      },
      "ResponseScalarDataFormatCustomAnnotatedConfig": {
         "additionalProperties": false,
         "description": "Selects custom-annotated tabular file format for experiment data",
         "properties": {
            "header": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Enable header row in custom-annotated tabular file",
               "title": "Header",
               "x-materialization": [
                  {
                     "ir_key": "responses.scalar_data_format",
                     "ir_value_type": "unsigned short",
                     "storage_type": "AUGMENT_ENUM",
                     "stored_value": "TABULAR_HEADER"
                  }
               ]
            },
            "exp_id": {
               "anyOf": [
                  {
                     "const": true,
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Enable experiment ID column in custom-annotated tabular file",
               "title": "Exp Id",
               "x-materialization": [
                  {
                     "ir_key": "responses.scalar_data_format",
                     "ir_value_type": "unsigned short",
                     "storage_type": "AUGMENT_ENUM",
                     "stored_value": "TABULAR_EVAL_ID"
                  }
               ]
            }
         },
         "title": "ResponseScalarDataFormatCustomAnnotatedConfig",
         "type": "object"
      },
      "ResponseScalarDataFormatFreeform": {
         "additionalProperties": false,
         "description": "Selects free-form tabular file format for experiment data",
         "properties": {
            "freeform": {
               "const": true,
               "default": true,
               "description": "Selects free-form tabular file format for experiment data",
               "title": "Freeform",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "responses.scalar_data_format",
                     "ir_value_type": "unsigned short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "TABULAR_NONE"
                  }
               ]
            }
         },
         "title": "ResponseScalarDataFormatFreeform",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:

• format (dakota.spec.shared.responses.ResponseScalarDataFormatCustomAnnotated | dakota.spec.shared.responses.ResponseScalarDataFormatAnnotated | dakota.spec.shared.responses.ResponseScalarDataFormatFreeform)

field format: ResponseScalarDataFormatCustomAnnotated | ResponseScalarDataFormatAnnotated | ResponseScalarDataFormatFreeform [Optional]

Tabular Format