Core

Generated Pydantic models for shared.core

pydantic model dakota.spec.shared.core.Active

use statistics for the active expansion within multifidelity refinement

Show JSON schema
{
   "title": "Active",
   "description": "use statistics for the active expansion within multifidelity refinement",
   "type": "object",
   "properties": {
      "active": {
         "const": true,
         "default": true,
         "description": "use statistics for the active expansion within multifidelity refinement",
         "title": "Active",
         "type": "boolean",
         "x-materialization": [
            {
               "enum_scope": "Pecos",
               "ir_key": "method.nond.refinement_statistics_mode",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "ACTIVE_EXPANSION_STATS"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field active: Literal[True] = True

use statistics for the active expansion within multifidelity refinement

pydantic model dakota.spec.shared.core.DefaultConstraintTolMixin

Generated model for DefaultConstraintTolMixin

Show JSON schema
{
   "title": "DefaultConstraintTolMixin",
   "description": "Generated model for DefaultConstraintTolMixin",
   "type": "object",
   "properties": {
      "constraint_tolerance": {
         "default": 0.0,
         "description": "Maximum allowable constraint violation still considered feasible",
         "title": "Constraint Tolerance",
         "type": "number",
         "x-materialization": [
            {
               "ir_key": "method.constraint_tolerance",
               "ir_value_type": "Real",
               "storage_type": "DIRECT_VALUE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field constraint_tolerance: DakotaFloat = 0.0

Maximum allowable constraint violation still considered feasible

Constraints:
  • func = <function _serialize_dakota_float at 0x7f2a3de76700>

  • return_type = float | str

  • when_used = json

pydantic model dakota.spec.shared.core.LevelMappings

Utilize the level mappings metric for guiding adaptive refinement during UQ.

Show JSON schema
{
   "title": "LevelMappings",
   "description": "Utilize the level mappings metric for guiding adaptive refinement during UQ.",
   "type": "object",
   "properties": {
      "level_mappings": {
         "const": true,
         "default": true,
         "description": "Utilize the level mappings metric for guiding adaptive refinement during UQ.",
         "title": "Level Mappings",
         "type": "boolean",
         "x-materialization": [
            {
               "enum_scope": "Pecos",
               "ir_key": "method.nond.expansion_refinement_metric",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "LEVEL_STATS_METRIC"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field level_mappings: Literal[True] = True

Utilize the level mappings metric for guiding adaptive refinement during UQ.

pydantic model dakota.spec.shared.core.MethodConvergenceTolMixin

Generated model for MethodConvergenceTolMixin

Show JSON schema
{
   "title": "MethodConvergenceTolMixin",
   "description": "Generated model for MethodConvergenceTolMixin",
   "type": "object",
   "properties": {
      "convergence_tolerance": {
         "default": -1.7976931348623157e+308,
         "description": "Stopping criterion based on objective function or statistics convergence",
         "title": "Convergence Tolerance",
         "type": "number",
         "x-materialization": [
            {
               "ir_key": "method.convergence_tolerance",
               "ir_value_type": "Real",
               "storage_type": "DIRECT_VALUE"
            },
            {
               "ir_key": "method.jega.percent_change",
               "ir_value_type": "Real",
               "storage_type": "DIRECT_VALUE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field convergence_tolerance: DakotaFloat = -1.7976931348623157e+308

Stopping criterion based on objective function or statistics convergence

Constraints:
  • func = <function _serialize_dakota_float at 0x7f2a3de76700>

  • return_type = float | str

  • when_used = json

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext1Absolute

Use absolute statistical metrics for assessing convergence in adaptive UQ methods

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext1Absolute",
   "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
   "type": "object",
   "properties": {
      "absolute": {
         "const": true,
         "default": true,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "title": "Absolute",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.convergence_tolerance_type",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field absolute: Literal[True] = True

Use absolute statistical metrics for assessing convergence in adaptive UQ methods

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext1ConvergenceTol

Stopping criterion based on relative error

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext1ConvergenceTol",
   "description": "Stopping criterion based on relative error",
   "type": "object",
   "properties": {
      "value": {
         "default": -1.7976931348623157e+308,
         "description": "Stopping criterion based on relative error",
         "title": "Value",
         "type": "number",
         "x-materialization": [
            {
               "ir_key": "method.convergence_tolerance",
               "ir_value_type": "Real",
               "storage_type": "DIRECT_VALUE"
            },
            {
               "ir_key": "method.jega.percent_change",
               "ir_value_type": "Real",
               "storage_type": "DIRECT_VALUE"
            }
         ]
      },
      "convergence_tolerance_type": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext1Relative"
            },
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext1Absolute"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Convergence tolerance type",
         "title": "Convergence Tolerance Type",
         "x-union-pattern": 2
      }
   },
   "$defs": {
      "MethodConvergenceTolWithTypeContext1Absolute": {
         "additionalProperties": false,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext1Absolute",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext1Relative": {
         "additionalProperties": false,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext1Relative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field convergence_tolerance_type: MethodConvergenceTolWithTypeContext1Relative | MethodConvergenceTolWithTypeContext1Absolute | None = None

Convergence tolerance type

field value: DakotaFloat = -1.7976931348623157e+308

Stopping criterion based on relative error

Constraints:
  • func = <function _serialize_dakota_float at 0x7f2a3de76700>

  • return_type = float | str

  • when_used = json

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext1Mixin

Generated model for MethodConvergenceTolWithTypeContext1Mixin

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext1Mixin",
   "description": "Generated model for MethodConvergenceTolWithTypeContext1Mixin",
   "type": "object",
   "properties": {
      "convergence_tolerance": {
         "anyOf": [
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext1ConvergenceTol"
            },
            {
               "type": "null"
            }
         ],
         "argument": "value",
         "default": null,
         "description": "Stopping criterion based on relative error"
      }
   },
   "$defs": {
      "MethodConvergenceTolWithTypeContext1Absolute": {
         "additionalProperties": false,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext1Absolute",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext1ConvergenceTol": {
         "additionalProperties": false,
         "description": "Stopping criterion based on relative error",
         "properties": {
            "value": {
               "default": -1.7976931348623157e+308,
               "description": "Stopping criterion based on relative error",
               "title": "Value",
               "type": "number",
               "x-materialization": [
                  {
                     "ir_key": "method.convergence_tolerance",
                     "ir_value_type": "Real",
                     "storage_type": "DIRECT_VALUE"
                  },
                  {
                     "ir_key": "method.jega.percent_change",
                     "ir_value_type": "Real",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            },
            "convergence_tolerance_type": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MethodConvergenceTolWithTypeContext1Relative"
                  },
                  {
                     "$ref": "#/$defs/MethodConvergenceTolWithTypeContext1Absolute"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Convergence tolerance type",
               "title": "Convergence Tolerance Type",
               "x-union-pattern": 2
            }
         },
         "title": "MethodConvergenceTolWithTypeContext1ConvergenceTol",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext1Relative": {
         "additionalProperties": false,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext1Relative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field convergence_tolerance: MethodConvergenceTolWithTypeContext1ConvergenceTol | None = None

Stopping criterion based on relative error

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext1Relative

Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext1Relative",
   "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
   "type": "object",
   "properties": {
      "relative": {
         "const": true,
         "default": true,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "title": "Relative",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.convergence_tolerance_type",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field relative: Literal[True] = True

Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext2Absolute

Use absolute statistical metrics for assessing convergence in adaptive UQ methods

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext2Absolute",
   "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
   "type": "object",
   "properties": {
      "absolute": {
         "const": true,
         "default": true,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "title": "Absolute",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.convergence_tolerance_type",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field absolute: Literal[True] = True

Use absolute statistical metrics for assessing convergence in adaptive UQ methods

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext2ConvergenceTol

Stopping criterion based on objective function or statistics convergence

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext2ConvergenceTol",
   "description": "Stopping criterion based on objective function or statistics convergence",
   "type": "object",
   "properties": {
      "value": {
         "default": -1.7976931348623157e+308,
         "description": "Stopping criterion based on objective function or statistics convergence",
         "title": "Value",
         "type": "number",
         "x-materialization": [
            {
               "ir_key": "method.convergence_tolerance",
               "ir_value_type": "Real",
               "storage_type": "DIRECT_VALUE"
            },
            {
               "ir_key": "method.jega.percent_change",
               "ir_value_type": "Real",
               "storage_type": "DIRECT_VALUE"
            }
         ]
      },
      "convergence_tolerance_type": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2Relative"
            },
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2Absolute"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Convergence tolerance type",
         "title": "Convergence Tolerance Type",
         "x-union-pattern": 2
      }
   },
   "$defs": {
      "MethodConvergenceTolWithTypeContext2Absolute": {
         "additionalProperties": false,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2Absolute",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext2Relative": {
         "additionalProperties": false,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2Relative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field convergence_tolerance_type: MethodConvergenceTolWithTypeContext2Relative | MethodConvergenceTolWithTypeContext2Absolute | None = None

Convergence tolerance type

field value: DakotaFloat = -1.7976931348623157e+308

Stopping criterion based on objective function or statistics convergence

Constraints:
  • func = <function _serialize_dakota_float at 0x7f2a3de76700>

  • return_type = float | str

  • when_used = json

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext2Mixin

Generated model for MethodConvergenceTolWithTypeContext2Mixin

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext2Mixin",
   "description": "Generated model for MethodConvergenceTolWithTypeContext2Mixin",
   "type": "object",
   "properties": {
      "convergence_tolerance": {
         "anyOf": [
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2ConvergenceTol"
            },
            {
               "type": "null"
            }
         ],
         "argument": "value",
         "default": null,
         "description": "Stopping criterion based on objective function or statistics convergence"
      }
   },
   "$defs": {
      "MethodConvergenceTolWithTypeContext2Absolute": {
         "additionalProperties": false,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2Absolute",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext2ConvergenceTol": {
         "additionalProperties": false,
         "description": "Stopping criterion based on objective function or statistics convergence",
         "properties": {
            "value": {
               "default": -1.7976931348623157e+308,
               "description": "Stopping criterion based on objective function or statistics convergence",
               "title": "Value",
               "type": "number",
               "x-materialization": [
                  {
                     "ir_key": "method.convergence_tolerance",
                     "ir_value_type": "Real",
                     "storage_type": "DIRECT_VALUE"
                  },
                  {
                     "ir_key": "method.jega.percent_change",
                     "ir_value_type": "Real",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            },
            "convergence_tolerance_type": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2Relative"
                  },
                  {
                     "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2Absolute"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Convergence tolerance type",
               "title": "Convergence Tolerance Type",
               "x-union-pattern": 2
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2ConvergenceTol",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext2Relative": {
         "additionalProperties": false,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2Relative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field convergence_tolerance: MethodConvergenceTolWithTypeContext2ConvergenceTol | None = None

Stopping criterion based on objective function or statistics convergence

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext2Relative

Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext2Relative",
   "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
   "type": "object",
   "properties": {
      "relative": {
         "const": true,
         "default": true,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "title": "Relative",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.convergence_tolerance_type",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field relative: Literal[True] = True

Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext3Absolute

Use absolute statistical metrics for assessing convergence in adaptive UQ methods

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext3Absolute",
   "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
   "type": "object",
   "properties": {
      "absolute": {
         "const": true,
         "default": true,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "title": "Absolute",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.convergence_tolerance_type",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field absolute: Literal[True] = True

Use absolute statistical metrics for assessing convergence in adaptive UQ methods

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext3ConvergenceTol

Stopping criterion based on relative error reduction

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext3ConvergenceTol",
   "description": "Stopping criterion based on relative error reduction",
   "type": "object",
   "properties": {
      "value": {
         "default": -1.7976931348623157e+308,
         "description": "Stopping criterion based on relative error reduction",
         "title": "Value",
         "type": "number",
         "x-materialization": [
            {
               "ir_key": "method.convergence_tolerance",
               "ir_value_type": "Real",
               "storage_type": "DIRECT_VALUE"
            },
            {
               "ir_key": "method.jega.percent_change",
               "ir_value_type": "Real",
               "storage_type": "DIRECT_VALUE"
            }
         ]
      },
      "convergence_tolerance_type": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext3Relative"
            },
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext3Absolute"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Convergence tolerance type",
         "title": "Convergence Tolerance Type",
         "x-union-pattern": 2
      }
   },
   "$defs": {
      "MethodConvergenceTolWithTypeContext3Absolute": {
         "additionalProperties": false,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext3Absolute",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext3Relative": {
         "additionalProperties": false,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext3Relative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field convergence_tolerance_type: MethodConvergenceTolWithTypeContext3Relative | MethodConvergenceTolWithTypeContext3Absolute | None = None

Convergence tolerance type

field value: DakotaFloat = -1.7976931348623157e+308

Stopping criterion based on relative error reduction

Constraints:
  • func = <function _serialize_dakota_float at 0x7f2a3de76700>

  • return_type = float | str

  • when_used = json

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext3Mixin

Generated model for MethodConvergenceTolWithTypeContext3Mixin

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext3Mixin",
   "description": "Generated model for MethodConvergenceTolWithTypeContext3Mixin",
   "type": "object",
   "properties": {
      "convergence_tolerance": {
         "anyOf": [
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext3ConvergenceTol"
            },
            {
               "type": "null"
            }
         ],
         "argument": "value",
         "default": null,
         "description": "Stopping criterion based on relative error reduction"
      }
   },
   "$defs": {
      "MethodConvergenceTolWithTypeContext3Absolute": {
         "additionalProperties": false,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext3Absolute",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext3ConvergenceTol": {
         "additionalProperties": false,
         "description": "Stopping criterion based on relative error reduction",
         "properties": {
            "value": {
               "default": -1.7976931348623157e+308,
               "description": "Stopping criterion based on relative error reduction",
               "title": "Value",
               "type": "number",
               "x-materialization": [
                  {
                     "ir_key": "method.convergence_tolerance",
                     "ir_value_type": "Real",
                     "storage_type": "DIRECT_VALUE"
                  },
                  {
                     "ir_key": "method.jega.percent_change",
                     "ir_value_type": "Real",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            },
            "convergence_tolerance_type": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MethodConvergenceTolWithTypeContext3Relative"
                  },
                  {
                     "$ref": "#/$defs/MethodConvergenceTolWithTypeContext3Absolute"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Convergence tolerance type",
               "title": "Convergence Tolerance Type",
               "x-union-pattern": 2
            }
         },
         "title": "MethodConvergenceTolWithTypeContext3ConvergenceTol",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext3Relative": {
         "additionalProperties": false,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext3Relative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field convergence_tolerance: MethodConvergenceTolWithTypeContext3ConvergenceTol | None = None

Stopping criterion based on relative error reduction

pydantic model dakota.spec.shared.core.MethodConvergenceTolWithTypeContext3Relative

Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark

Show JSON schema
{
   "title": "MethodConvergenceTolWithTypeContext3Relative",
   "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
   "type": "object",
   "properties": {
      "relative": {
         "const": true,
         "default": true,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "title": "Relative",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.convergence_tolerance_type",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field relative: Literal[True] = True

Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark

pydantic model dakota.spec.shared.core.MethodExpConvergenceToleranceMixin

Generated model for MethodExpConvergenceToleranceMixin

Show JSON schema
{
   "title": "MethodExpConvergenceToleranceMixin",
   "description": "Generated model for MethodExpConvergenceToleranceMixin",
   "type": "object",
   "properties": {
      "refinement_metric": {
         "anyOf": [
            {
               "$ref": "#/$defs/LevelMappings"
            },
            {
               "$ref": "#/$defs/RefinementMetricCov"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Metric used for guiding adaptive refinement during UQ.",
         "title": "Refinement Metric",
         "x-union-pattern": 2
      },
      "convergence_tolerance": {
         "anyOf": [
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2ConvergenceTol"
            },
            {
               "type": "null"
            }
         ],
         "argument": "value",
         "default": null,
         "description": "Stopping criterion based on objective function or statistics convergence"
      }
   },
   "$defs": {
      "LevelMappings": {
         "additionalProperties": false,
         "description": "Utilize the level mappings metric for guiding adaptive refinement during UQ.",
         "properties": {
            "level_mappings": {
               "const": true,
               "default": true,
               "description": "Utilize the level mappings metric for guiding adaptive refinement during UQ.",
               "title": "Level Mappings",
               "type": "boolean",
               "x-materialization": [
                  {
                     "enum_scope": "Pecos",
                     "ir_key": "method.nond.expansion_refinement_metric",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "LEVEL_STATS_METRIC"
                  }
               ]
            }
         },
         "title": "LevelMappings",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext2Absolute": {
         "additionalProperties": false,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2Absolute",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext2ConvergenceTol": {
         "additionalProperties": false,
         "description": "Stopping criterion based on objective function or statistics convergence",
         "properties": {
            "value": {
               "default": -1.7976931348623157e+308,
               "description": "Stopping criterion based on objective function or statistics convergence",
               "title": "Value",
               "type": "number",
               "x-materialization": [
                  {
                     "ir_key": "method.convergence_tolerance",
                     "ir_value_type": "Real",
                     "storage_type": "DIRECT_VALUE"
                  },
                  {
                     "ir_key": "method.jega.percent_change",
                     "ir_value_type": "Real",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            },
            "convergence_tolerance_type": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2Relative"
                  },
                  {
                     "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2Absolute"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Convergence tolerance type",
               "title": "Convergence Tolerance Type",
               "x-union-pattern": 2
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2ConvergenceTol",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext2Relative": {
         "additionalProperties": false,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2Relative",
         "type": "object"
      },
      "RefinementMetricCov": {
         "additionalProperties": false,
         "description": "Utilize the response covariance metric for guiding adaptive refinement during UQ.",
         "properties": {
            "covariance": {
               "const": true,
               "default": true,
               "description": "Utilize the response covariance metric for guiding adaptive refinement during UQ.",
               "title": "Covariance",
               "type": "boolean",
               "x-materialization": [
                  {
                     "enum_scope": "Pecos",
                     "ir_key": "method.nond.expansion_refinement_metric",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "COVARIANCE_METRIC"
                  }
               ]
            }
         },
         "title": "RefinementMetricCov",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field convergence_tolerance: MethodConvergenceTolWithTypeContext2ConvergenceTol | None = None

Stopping criterion based on objective function or statistics convergence

field refinement_metric: LevelMappings | RefinementMetricCov | None = None

Metric used for guiding adaptive refinement during UQ.

pydantic model dakota.spec.shared.core.MethodMfExpConvergenceToleranceMixin

Generated model for MethodMfExpConvergenceToleranceMixin

Show JSON schema
{
   "title": "MethodMfExpConvergenceToleranceMixin",
   "description": "Generated model for MethodMfExpConvergenceToleranceMixin",
   "type": "object",
   "properties": {
      "refinement_metric": {
         "anyOf": [
            {
               "$ref": "#/$defs/LevelMappings"
            },
            {
               "$ref": "#/$defs/RefinementMetricCov"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Metric used for guiding adaptive refinement during UQ.",
         "title": "Refinement Metric",
         "x-union-pattern": 2
      },
      "statistics_mode": {
         "anyOf": [
            {
               "$ref": "#/$defs/Active"
            },
            {
               "$ref": "#/$defs/StatisticsModeCombined"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "type of statistical metric roll-up for multifidelity UQ methods",
         "title": "Statistics Mode",
         "x-union-pattern": 2
      },
      "convergence_tolerance": {
         "anyOf": [
            {
               "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2ConvergenceTol"
            },
            {
               "type": "null"
            }
         ],
         "argument": "value",
         "default": null,
         "description": "Stopping criterion based on objective function or statistics convergence"
      }
   },
   "$defs": {
      "Active": {
         "additionalProperties": false,
         "description": "use statistics for the active expansion within multifidelity refinement",
         "properties": {
            "active": {
               "const": true,
               "default": true,
               "description": "use statistics for the active expansion within multifidelity refinement",
               "title": "Active",
               "type": "boolean",
               "x-materialization": [
                  {
                     "enum_scope": "Pecos",
                     "ir_key": "method.nond.refinement_statistics_mode",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "ACTIVE_EXPANSION_STATS"
                  }
               ]
            }
         },
         "title": "Active",
         "type": "object"
      },
      "LevelMappings": {
         "additionalProperties": false,
         "description": "Utilize the level mappings metric for guiding adaptive refinement during UQ.",
         "properties": {
            "level_mappings": {
               "const": true,
               "default": true,
               "description": "Utilize the level mappings metric for guiding adaptive refinement during UQ.",
               "title": "Level Mappings",
               "type": "boolean",
               "x-materialization": [
                  {
                     "enum_scope": "Pecos",
                     "ir_key": "method.nond.expansion_refinement_metric",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "LEVEL_STATS_METRIC"
                  }
               ]
            }
         },
         "title": "LevelMappings",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext2Absolute": {
         "additionalProperties": false,
         "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
         "properties": {
            "absolute": {
               "const": true,
               "default": true,
               "description": "Use absolute statistical metrics for assessing convergence in adaptive UQ methods",
               "title": "Absolute",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "ABSOLUTE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2Absolute",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext2ConvergenceTol": {
         "additionalProperties": false,
         "description": "Stopping criterion based on objective function or statistics convergence",
         "properties": {
            "value": {
               "default": -1.7976931348623157e+308,
               "description": "Stopping criterion based on objective function or statistics convergence",
               "title": "Value",
               "type": "number",
               "x-materialization": [
                  {
                     "ir_key": "method.convergence_tolerance",
                     "ir_value_type": "Real",
                     "storage_type": "DIRECT_VALUE"
                  },
                  {
                     "ir_key": "method.jega.percent_change",
                     "ir_value_type": "Real",
                     "storage_type": "DIRECT_VALUE"
                  }
               ]
            },
            "convergence_tolerance_type": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2Relative"
                  },
                  {
                     "$ref": "#/$defs/MethodConvergenceTolWithTypeContext2Absolute"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Convergence tolerance type",
               "title": "Convergence Tolerance Type",
               "x-union-pattern": 2
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2ConvergenceTol",
         "type": "object"
      },
      "MethodConvergenceTolWithTypeContext2Relative": {
         "additionalProperties": false,
         "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
         "properties": {
            "relative": {
               "const": true,
               "default": true,
               "description": "Assess convergence in adaptive UQ methods using statistical metrics that are relative to a benchmark",
               "title": "Relative",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.convergence_tolerance_type",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELATIVE_CONVERGENCE_TOLERANCE"
                  }
               ]
            }
         },
         "title": "MethodConvergenceTolWithTypeContext2Relative",
         "type": "object"
      },
      "RefinementMetricCov": {
         "additionalProperties": false,
         "description": "Utilize the response covariance metric for guiding adaptive refinement during UQ.",
         "properties": {
            "covariance": {
               "const": true,
               "default": true,
               "description": "Utilize the response covariance metric for guiding adaptive refinement during UQ.",
               "title": "Covariance",
               "type": "boolean",
               "x-materialization": [
                  {
                     "enum_scope": "Pecos",
                     "ir_key": "method.nond.expansion_refinement_metric",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "COVARIANCE_METRIC"
                  }
               ]
            }
         },
         "title": "RefinementMetricCov",
         "type": "object"
      },
      "StatisticsModeCombined": {
         "additionalProperties": false,
         "description": "use statistics for the combined expansion within multifidelity refinement",
         "properties": {
            "combined": {
               "const": true,
               "default": true,
               "description": "use statistics for the combined expansion within multifidelity refinement",
               "title": "Combined",
               "type": "boolean",
               "x-materialization": [
                  {
                     "enum_scope": "Pecos",
                     "ir_key": "method.nond.refinement_statistics_mode",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "COMBINED_EXPANSION_STATS"
                  }
               ]
            }
         },
         "title": "StatisticsModeCombined",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field convergence_tolerance: MethodConvergenceTolWithTypeContext2ConvergenceTol | None = None

Stopping criterion based on objective function or statistics convergence

field refinement_metric: LevelMappings | RefinementMetricCov | None = None

Metric used for guiding adaptive refinement during UQ.

field statistics_mode: Active | StatisticsModeCombined | None = None

type of statistical metric roll-up for multifidelity UQ methods

pydantic model dakota.spec.shared.core.MethodMfRefineStatsModeMixin

Generated model for MethodMfRefineStatsModeMixin

Show JSON schema
{
   "title": "MethodMfRefineStatsModeMixin",
   "description": "Generated model for MethodMfRefineStatsModeMixin",
   "type": "object",
   "properties": {
      "statistics_mode": {
         "anyOf": [
            {
               "$ref": "#/$defs/Active"
            },
            {
               "$ref": "#/$defs/StatisticsModeCombined"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "type of statistical metric roll-up for multifidelity UQ methods",
         "title": "Statistics Mode",
         "x-union-pattern": 2
      }
   },
   "$defs": {
      "Active": {
         "additionalProperties": false,
         "description": "use statistics for the active expansion within multifidelity refinement",
         "properties": {
            "active": {
               "const": true,
               "default": true,
               "description": "use statistics for the active expansion within multifidelity refinement",
               "title": "Active",
               "type": "boolean",
               "x-materialization": [
                  {
                     "enum_scope": "Pecos",
                     "ir_key": "method.nond.refinement_statistics_mode",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "ACTIVE_EXPANSION_STATS"
                  }
               ]
            }
         },
         "title": "Active",
         "type": "object"
      },
      "StatisticsModeCombined": {
         "additionalProperties": false,
         "description": "use statistics for the combined expansion within multifidelity refinement",
         "properties": {
            "combined": {
               "const": true,
               "default": true,
               "description": "use statistics for the combined expansion within multifidelity refinement",
               "title": "Combined",
               "type": "boolean",
               "x-materialization": [
                  {
                     "enum_scope": "Pecos",
                     "ir_key": "method.nond.refinement_statistics_mode",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "COMBINED_EXPANSION_STATS"
                  }
               ]
            }
         },
         "title": "StatisticsModeCombined",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field statistics_mode: Active | StatisticsModeCombined | None = None

type of statistical metric roll-up for multifidelity UQ methods

pydantic model dakota.spec.shared.core.MethodRefineMetricTypeMixin

Generated model for MethodRefineMetricTypeMixin

Show JSON schema
{
   "title": "MethodRefineMetricTypeMixin",
   "description": "Generated model for MethodRefineMetricTypeMixin",
   "type": "object",
   "properties": {
      "refinement_metric": {
         "anyOf": [
            {
               "$ref": "#/$defs/LevelMappings"
            },
            {
               "$ref": "#/$defs/RefinementMetricCov"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Metric used for guiding adaptive refinement during UQ.",
         "title": "Refinement Metric",
         "x-union-pattern": 2
      }
   },
   "$defs": {
      "LevelMappings": {
         "additionalProperties": false,
         "description": "Utilize the level mappings metric for guiding adaptive refinement during UQ.",
         "properties": {
            "level_mappings": {
               "const": true,
               "default": true,
               "description": "Utilize the level mappings metric for guiding adaptive refinement during UQ.",
               "title": "Level Mappings",
               "type": "boolean",
               "x-materialization": [
                  {
                     "enum_scope": "Pecos",
                     "ir_key": "method.nond.expansion_refinement_metric",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "LEVEL_STATS_METRIC"
                  }
               ]
            }
         },
         "title": "LevelMappings",
         "type": "object"
      },
      "RefinementMetricCov": {
         "additionalProperties": false,
         "description": "Utilize the response covariance metric for guiding adaptive refinement during UQ.",
         "properties": {
            "covariance": {
               "const": true,
               "default": true,
               "description": "Utilize the response covariance metric for guiding adaptive refinement during UQ.",
               "title": "Covariance",
               "type": "boolean",
               "x-materialization": [
                  {
                     "enum_scope": "Pecos",
                     "ir_key": "method.nond.expansion_refinement_metric",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "COVARIANCE_METRIC"
                  }
               ]
            }
         },
         "title": "RefinementMetricCov",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field refinement_metric: LevelMappings | RefinementMetricCov | None = None

Metric used for guiding adaptive refinement during UQ.

pydantic model dakota.spec.shared.core.NumericalGradientOptionsIntervalTypeCentral

Use central differences

Show JSON schema
{
   "title": "NumericalGradientOptionsIntervalTypeCentral",
   "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:
field central: Literal[True] = True

Use central differences

pydantic model dakota.spec.shared.core.NumericalGradientOptionsIntervalTypeForward

(Default) Use forward differences

Show JSON schema
{
   "title": "NumericalGradientOptionsIntervalTypeForward",
   "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:
field forward: Literal[True] = True

(Default) Use forward differences

pydantic model dakota.spec.shared.core.NumericalGradientOptionsMethodSourceDakota

(Default) Use internal Dakota finite differences algorithm

Show JSON schema
{
   "title": "NumericalGradientOptionsMethodSourceDakota",
   "description": "(Default) Use internal Dakota finite differences algorithm",
   "type": "object",
   "properties": {
      "dakota": {
         "$ref": "#/$defs/NumericalGradientOptionsMethodSourceDakotaConfig",
         "x-materialization": [
            {
               "ir_key": "responses.method_source",
               "ir_value_type": "String",
               "storage_type": "PRESENCE_LITERAL",
               "stored_value": "dakota"
            }
         ],
         "x-model-default": "NumericalGradientOptionsMethodSourceDakotaConfig"
      }
   },
   "$defs": {
      "NumericalGradientOptionsMethodSourceDakotaAbsolute": {
         "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": "NumericalGradientOptionsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceDakotaBounds": {
         "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": "NumericalGradientOptionsMethodSourceDakotaBounds",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceDakotaConfig": {
         "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/NumericalGradientOptionsMethodSourceDakotaRelative"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientOptionsMethodSourceDakotaAbsolute"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientOptionsMethodSourceDakotaBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "NumericalGradientOptionsMethodSourceDakotaRelative",
               "x-union-pattern": 1
            }
         },
         "title": "NumericalGradientOptionsMethodSourceDakotaConfig",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceDakotaRelative": {
         "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": "NumericalGradientOptionsMethodSourceDakotaRelative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field dakota: NumericalGradientOptionsMethodSourceDakotaConfig [Optional]

(Default) Use internal Dakota finite differences algorithm

pydantic model dakota.spec.shared.core.NumericalGradientOptionsMethodSourceDakotaAbsolute

Do not scale step-size

Show JSON schema
{
   "title": "NumericalGradientOptionsMethodSourceDakotaAbsolute",
   "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:
field absolute: Literal[True] = True

Do not scale step-size

pydantic model dakota.spec.shared.core.NumericalGradientOptionsMethodSourceDakotaBounds

Scale step-size by the domain of the parameter

Show JSON schema
{
   "title": "NumericalGradientOptionsMethodSourceDakotaBounds",
   "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:
field bounds: Literal[True] = True

Scale step-size by the domain of the parameter

pydantic model dakota.spec.shared.core.NumericalGradientOptionsMethodSourceDakotaConfig

(Default) Use internal Dakota finite differences algorithm

Show JSON schema
{
   "title": "NumericalGradientOptionsMethodSourceDakotaConfig",
   "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/NumericalGradientOptionsMethodSourceDakotaRelative"
            },
            {
               "$ref": "#/$defs/NumericalGradientOptionsMethodSourceDakotaAbsolute"
            },
            {
               "$ref": "#/$defs/NumericalGradientOptionsMethodSourceDakotaBounds"
            }
         ],
         "description": "Step Scaling",
         "title": "Step Scaling",
         "x-model-default": "NumericalGradientOptionsMethodSourceDakotaRelative",
         "x-union-pattern": 1
      }
   },
   "$defs": {
      "NumericalGradientOptionsMethodSourceDakotaAbsolute": {
         "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": "NumericalGradientOptionsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceDakotaBounds": {
         "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": "NumericalGradientOptionsMethodSourceDakotaBounds",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceDakotaRelative": {
         "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": "NumericalGradientOptionsMethodSourceDakotaRelative",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field ignore_bounds: Literal[True] | None = None

Do not respect bounds when computing gradients or Hessians

field step_scaling: NumericalGradientOptionsMethodSourceDakotaRelative | NumericalGradientOptionsMethodSourceDakotaAbsolute | NumericalGradientOptionsMethodSourceDakotaBounds [Optional]

Step Scaling

pydantic model dakota.spec.shared.core.NumericalGradientOptionsMethodSourceDakotaRelative

(Default) Scale step size by the parameter value

Show JSON schema
{
   "title": "NumericalGradientOptionsMethodSourceDakotaRelative",
   "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:
field relative: Literal[True] = True

(Default) Scale step size by the parameter value

pydantic model dakota.spec.shared.core.NumericalGradientOptionsMethodSourceVendor

Use non-Dakota fd algorithm

Show JSON schema
{
   "title": "NumericalGradientOptionsMethodSourceVendor",
   "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:
field vendor: Literal[True] = True

Use non-Dakota fd algorithm

pydantic model dakota.spec.shared.core.NumericalGradientOptionsMixin

Generated model for NumericalGradientOptionsMixin

Show JSON schema
{
   "title": "NumericalGradientOptionsMixin",
   "description": "Generated model for NumericalGradientOptionsMixin",
   "type": "object",
   "properties": {
      "method_source": {
         "anyOf": [
            {
               "$ref": "#/$defs/NumericalGradientOptionsMethodSourceDakota"
            },
            {
               "$ref": "#/$defs/NumericalGradientOptionsMethodSourceVendor"
            }
         ],
         "description": "Specify which finite difference routine is used",
         "title": "Method Source",
         "x-model-default": "NumericalGradientOptionsMethodSourceDakota",
         "x-union-pattern": 1
      },
      "interval_type": {
         "anyOf": [
            {
               "$ref": "#/$defs/NumericalGradientOptionsIntervalTypeForward"
            },
            {
               "$ref": "#/$defs/NumericalGradientOptionsIntervalTypeCentral"
            }
         ],
         "description": "Specify how to compute gradients and hessians",
         "title": "Interval Type",
         "x-model-default": "NumericalGradientOptionsIntervalTypeForward",
         "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": {
      "NumericalGradientOptionsIntervalTypeCentral": {
         "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": "NumericalGradientOptionsIntervalTypeCentral",
         "type": "object"
      },
      "NumericalGradientOptionsIntervalTypeForward": {
         "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": "NumericalGradientOptionsIntervalTypeForward",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceDakota": {
         "additionalProperties": false,
         "description": "(Default) Use internal Dakota finite differences algorithm",
         "properties": {
            "dakota": {
               "$ref": "#/$defs/NumericalGradientOptionsMethodSourceDakotaConfig",
               "x-materialization": [
                  {
                     "ir_key": "responses.method_source",
                     "ir_value_type": "String",
                     "storage_type": "PRESENCE_LITERAL",
                     "stored_value": "dakota"
                  }
               ],
               "x-model-default": "NumericalGradientOptionsMethodSourceDakotaConfig"
            }
         },
         "title": "NumericalGradientOptionsMethodSourceDakota",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceDakotaAbsolute": {
         "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": "NumericalGradientOptionsMethodSourceDakotaAbsolute",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceDakotaBounds": {
         "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": "NumericalGradientOptionsMethodSourceDakotaBounds",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceDakotaConfig": {
         "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/NumericalGradientOptionsMethodSourceDakotaRelative"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientOptionsMethodSourceDakotaAbsolute"
                  },
                  {
                     "$ref": "#/$defs/NumericalGradientOptionsMethodSourceDakotaBounds"
                  }
               ],
               "description": "Step Scaling",
               "title": "Step Scaling",
               "x-model-default": "NumericalGradientOptionsMethodSourceDakotaRelative",
               "x-union-pattern": 1
            }
         },
         "title": "NumericalGradientOptionsMethodSourceDakotaConfig",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceDakotaRelative": {
         "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": "NumericalGradientOptionsMethodSourceDakotaRelative",
         "type": "object"
      },
      "NumericalGradientOptionsMethodSourceVendor": {
         "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": "NumericalGradientOptionsMethodSourceVendor",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field fd_step_size: list[DakotaFloat] | None = None

Step size used when computing gradients and Hessians

field interval_type: NumericalGradientOptionsIntervalTypeForward | NumericalGradientOptionsIntervalTypeCentral [Optional]

Specify how to compute gradients and hessians

field method_source: NumericalGradientOptionsMethodSourceDakota | NumericalGradientOptionsMethodSourceVendor [Optional]

Specify which finite difference routine is used

pydantic model dakota.spec.shared.core.RefinementMetricCov

Utilize the response covariance metric for guiding adaptive refinement during UQ.

Show JSON schema
{
   "title": "RefinementMetricCov",
   "description": "Utilize the response covariance metric for guiding adaptive refinement during UQ.",
   "type": "object",
   "properties": {
      "covariance": {
         "const": true,
         "default": true,
         "description": "Utilize the response covariance metric for guiding adaptive refinement during UQ.",
         "title": "Covariance",
         "type": "boolean",
         "x-materialization": [
            {
               "enum_scope": "Pecos",
               "ir_key": "method.nond.expansion_refinement_metric",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "COVARIANCE_METRIC"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field covariance: Literal[True] = True

Utilize the response covariance metric for guiding adaptive refinement during UQ.

pydantic model dakota.spec.shared.core.ResponseLevelsComputeProbRelGenCompute

Selection of statistics to compute at each response level

Show JSON schema
{
   "title": "ResponseLevelsComputeProbRelGenCompute",
   "description": "Selection of statistics to compute at each response level",
   "type": "object",
   "properties": {
      "statistic": {
         "anchor": true,
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbRelGenProbabilities"
            },
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbRelGenReliabilities"
            },
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbRelGenGenReliabilities"
            }
         ],
         "description": "Statistics to Compute",
         "title": "Statistic",
         "x-union-pattern": 4
      },
      "system": {
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbRelGenSystemSeries"
            },
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbRelGenSystemParallel"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Compute system reliability (series or parallel)",
         "title": "System",
         "x-union-pattern": 2
      }
   },
   "$defs": {
      "ResponseLevelsComputeProbRelGenGenReliabilities": {
         "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": "ResponseLevelsComputeProbRelGenGenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenProbabilities": {
         "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": "ResponseLevelsComputeProbRelGenProbabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenReliabilities": {
         "additionalProperties": false,
         "description": "Computes reliabilities associated with response levels",
         "properties": {
            "reliabilities": {
               "const": true,
               "default": true,
               "description": "Computes reliabilities associated with response levels",
               "title": "Reliabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELIABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbRelGenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenSystemParallel": {
         "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": "ResponseLevelsComputeProbRelGenSystemParallel",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenSystemSeries": {
         "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": "ResponseLevelsComputeProbRelGenSystemSeries",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "statistic"
   ]
}

Fields:
field statistic: ResponseLevelsComputeProbRelGenProbabilities | ResponseLevelsComputeProbRelGenReliabilities | ResponseLevelsComputeProbRelGenGenReliabilities [Required]

Statistics to Compute

field system: ResponseLevelsComputeProbRelGenSystemSeries | ResponseLevelsComputeProbRelGenSystemParallel | None = None

Compute system reliability (series or parallel)

pydantic model dakota.spec.shared.core.ResponseLevelsComputeProbRelGenGenReliabilities

Computes generalized reliabilities associated with response levels

Show JSON schema
{
   "title": "ResponseLevelsComputeProbRelGenGenReliabilities",
   "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:
field gen_reliabilities: Literal[True] = True

Computes generalized reliabilities associated with response levels

pydantic model dakota.spec.shared.core.ResponseLevelsComputeProbRelGenMixin

Generated model for ResponseLevelsComputeProbRelGenMixin

Show JSON schema
{
   "title": "ResponseLevelsComputeProbRelGenMixin",
   "description": "Generated model for ResponseLevelsComputeProbRelGenMixin",
   "type": "object",
   "properties": {
      "response_levels": {
         "anyOf": [
            {
               "$ref": "#/$defs/ResponseLevelsComputeProbRelGenResponseLevels"
            },
            {
               "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": {
      "ResponseLevelsComputeProbRelGenCompute": {
         "additionalProperties": false,
         "description": "Selection of statistics to compute at each response level",
         "properties": {
            "statistic": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbRelGenProbabilities"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbRelGenReliabilities"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbRelGenGenReliabilities"
                  }
               ],
               "description": "Statistics to Compute",
               "title": "Statistic",
               "x-union-pattern": 4
            },
            "system": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbRelGenSystemSeries"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbRelGenSystemParallel"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Compute system reliability (series or parallel)",
               "title": "System",
               "x-union-pattern": 2
            }
         },
         "required": [
            "statistic"
         ],
         "title": "ResponseLevelsComputeProbRelGenCompute",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenGenReliabilities": {
         "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": "ResponseLevelsComputeProbRelGenGenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenProbabilities": {
         "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": "ResponseLevelsComputeProbRelGenProbabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenReliabilities": {
         "additionalProperties": false,
         "description": "Computes reliabilities associated with response levels",
         "properties": {
            "reliabilities": {
               "const": true,
               "default": true,
               "description": "Computes reliabilities associated with response levels",
               "title": "Reliabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELIABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbRelGenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenResponseLevels": {
         "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/ResponseLevelsComputeProbRelGenCompute"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Selection of statistics to compute at each response level"
            }
         },
         "required": [
            "values"
         ],
         "title": "ResponseLevelsComputeProbRelGenResponseLevels",
         "type": "object",
         "x-model-validations": [
            {
               "validationContext": "responselevelscomputeprobrelgenresponselevels",
               "validationErrorMessage": "For responselevelscomputeprobrelgenresponselevels, sum of num_response_levels must equal length of values.",
               "validationFields": [
                  "num_response_levels",
                  "values"
               ],
               "validationLiterals": [],
               "validationRuleName": "check_sum_equals_length"
            }
         ]
      },
      "ResponseLevelsComputeProbRelGenSystemParallel": {
         "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": "ResponseLevelsComputeProbRelGenSystemParallel",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenSystemSeries": {
         "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": "ResponseLevelsComputeProbRelGenSystemSeries",
         "type": "object"
      }
   },
   "additionalProperties": false
}

Fields:
field response_levels: ResponseLevelsComputeProbRelGenResponseLevels | None = None

Values at which to estimate desired statistics for each response

pydantic model dakota.spec.shared.core.ResponseLevelsComputeProbRelGenProbabilities

Computes probabilities associated with response levels

Show JSON schema
{
   "title": "ResponseLevelsComputeProbRelGenProbabilities",
   "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:
field probabilities: Literal[True] = True

Computes probabilities associated with response levels

pydantic model dakota.spec.shared.core.ResponseLevelsComputeProbRelGenReliabilities

Computes reliabilities associated with response levels

Show JSON schema
{
   "title": "ResponseLevelsComputeProbRelGenReliabilities",
   "description": "Computes reliabilities associated with response levels",
   "type": "object",
   "properties": {
      "reliabilities": {
         "const": true,
         "default": true,
         "description": "Computes reliabilities associated with response levels",
         "title": "Reliabilities",
         "type": "boolean",
         "x-materialization": [
            {
               "ir_key": "method.nond.response_level_target",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "RELIABILITIES"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field reliabilities: Literal[True] = True

Computes reliabilities associated with response levels

pydantic model dakota.spec.shared.core.ResponseLevelsComputeProbRelGenResponseLevels

Values at which to estimate desired statistics for each response

Show JSON schema
{
   "title": "ResponseLevelsComputeProbRelGenResponseLevels",
   "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/ResponseLevelsComputeProbRelGenCompute"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Selection of statistics to compute at each response level"
      }
   },
   "$defs": {
      "ResponseLevelsComputeProbRelGenCompute": {
         "additionalProperties": false,
         "description": "Selection of statistics to compute at each response level",
         "properties": {
            "statistic": {
               "anchor": true,
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbRelGenProbabilities"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbRelGenReliabilities"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbRelGenGenReliabilities"
                  }
               ],
               "description": "Statistics to Compute",
               "title": "Statistic",
               "x-union-pattern": 4
            },
            "system": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbRelGenSystemSeries"
                  },
                  {
                     "$ref": "#/$defs/ResponseLevelsComputeProbRelGenSystemParallel"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Compute system reliability (series or parallel)",
               "title": "System",
               "x-union-pattern": 2
            }
         },
         "required": [
            "statistic"
         ],
         "title": "ResponseLevelsComputeProbRelGenCompute",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenGenReliabilities": {
         "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": "ResponseLevelsComputeProbRelGenGenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenProbabilities": {
         "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": "ResponseLevelsComputeProbRelGenProbabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenReliabilities": {
         "additionalProperties": false,
         "description": "Computes reliabilities associated with response levels",
         "properties": {
            "reliabilities": {
               "const": true,
               "default": true,
               "description": "Computes reliabilities associated with response levels",
               "title": "Reliabilities",
               "type": "boolean",
               "x-materialization": [
                  {
                     "ir_key": "method.nond.response_level_target",
                     "ir_value_type": "short",
                     "storage_type": "PRESENCE_ENUM",
                     "stored_value": "RELIABILITIES"
                  }
               ]
            }
         },
         "title": "ResponseLevelsComputeProbRelGenReliabilities",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenSystemParallel": {
         "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": "ResponseLevelsComputeProbRelGenSystemParallel",
         "type": "object"
      },
      "ResponseLevelsComputeProbRelGenSystemSeries": {
         "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": "ResponseLevelsComputeProbRelGenSystemSeries",
         "type": "object"
      }
   },
   "additionalProperties": false,
   "required": [
      "values"
   ],
   "x-model-validations": [
      {
         "validationContext": "responselevelscomputeprobrelgenresponselevels",
         "validationErrorMessage": "For responselevelscomputeprobrelgenresponselevels, sum of num_response_levels must equal length of values.",
         "validationFields": [
            "num_response_levels",
            "values"
         ],
         "validationLiterals": [],
         "validationRuleName": "check_sum_equals_length"
      }
   ]
}

Fields:
field compute: ResponseLevelsComputeProbRelGenCompute | 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.core.ResponseLevelsComputeProbRelGenSystemParallel

Aggregate response statistics assuming a parallel system

Show JSON schema
{
   "title": "ResponseLevelsComputeProbRelGenSystemParallel",
   "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:
field parallel: Literal[True] = True

Aggregate response statistics assuming a parallel system

pydantic model dakota.spec.shared.core.ResponseLevelsComputeProbRelGenSystemSeries

Aggregate response statistics assuming a series system

Show JSON schema
{
   "title": "ResponseLevelsComputeProbRelGenSystemSeries",
   "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:
field series: Literal[True] = True

Aggregate response statistics assuming a series system

pydantic model dakota.spec.shared.core.StatisticsModeCombined

use statistics for the combined expansion within multifidelity refinement

Show JSON schema
{
   "title": "StatisticsModeCombined",
   "description": "use statistics for the combined expansion within multifidelity refinement",
   "type": "object",
   "properties": {
      "combined": {
         "const": true,
         "default": true,
         "description": "use statistics for the combined expansion within multifidelity refinement",
         "title": "Combined",
         "type": "boolean",
         "x-materialization": [
            {
               "enum_scope": "Pecos",
               "ir_key": "method.nond.refinement_statistics_mode",
               "ir_value_type": "short",
               "storage_type": "PRESENCE_ENUM",
               "stored_value": "COMBINED_EXPANSION_STATS"
            }
         ]
      }
   },
   "additionalProperties": false
}

Fields:
field combined: Literal[True] = True

use statistics for the combined expansion within multifidelity refinement