Optimal Control

SubModule Containing Optimal Control ODEs, Phases, and Utilities

class asset.OptimalControl.ControlModes

Bases: pybind11_object

Members:

HighestOrderSpline

FirstOrderSpline

NoSpline

BlockConstant

BlockConstant = <ControlModes.BlockConstant: 3>

FirstOrderSpline = <ControlModes.FirstOrderSpline: 1>

HighestOrderSpline = <ControlModes.HighestOrderSpline: 0>

NoSpline = <ControlModes.NoSpline: 2>

__eq__(self: object, other: object) → bool

__getstate__(self: object) → int

__hash__(self: object) → int

__index__(self: asset.OptimalControl.ControlModes) → int

__init__(self: asset.OptimalControl.ControlModes, value: int) → None

__int__(self: asset.OptimalControl.ControlModes) → int

__members__ = {'BlockConstant': <ControlModes.BlockConstant: 3>, 'FirstOrderSpline': <ControlModes.FirstOrderSpline: 1>, 'HighestOrderSpline': <ControlModes.HighestOrderSpline: 0>, 'NoSpline': <ControlModes.NoSpline: 2>}

__module__ = 'asset.OptimalControl'

__ne__(self: object, other: object) → bool

__repr__(self: object) → str

__setstate__(self: asset.OptimalControl.ControlModes, state: int) → None

__str__(self: object) → str

property name

property value

class asset.OptimalControl.FiniteDiffTable

Bases: pybind11_object

__init__(self: asset.OptimalControl.FiniteDiffTable, arg0: int, arg1: list[numpy.ndarray[numpy.float64[m, 1]]]) → None

__module__ = 'asset.OptimalControl'

all_derivs(self: asset.OptimalControl.FiniteDiffTable, arg0: int, arg1: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

deriv(self: asset.OptimalControl.FiniteDiffTable, arg0: int, arg1: int, arg2: int) → numpy.ndarray[numpy.float64[m, 1]]

class asset.OptimalControl.IntegralModes

Bases: pybind11_object

Members:

BaseIntegral

TrapIntegral

BaseIntegral = <IntegralModes.BaseIntegral: 0>

TrapIntegral = <IntegralModes.TrapIntegral: 2>

__eq__(self: object, other: object) → bool

__getstate__(self: object) → int

__hash__(self: object) → int

__index__(self: asset.OptimalControl.IntegralModes) → int

__init__(self: asset.OptimalControl.IntegralModes, value: int) → None

__int__(self: asset.OptimalControl.IntegralModes) → int

__members__ = {'BaseIntegral': <IntegralModes.BaseIntegral: 0>, 'TrapIntegral': <IntegralModes.TrapIntegral: 2>}

__module__ = 'asset.OptimalControl'

__ne__(self: object, other: object) → bool

__repr__(self: object) → str

__setstate__(self: asset.OptimalControl.IntegralModes, state: int) → None

__str__(self: object) → str

property name

property value

class asset.OptimalControl.InterpFunction

Bases: pybind11_object

IRows(self: asset.OptimalControl.InterpFunction) → int

ORows(self: asset.OptimalControl.InterpFunction) → int

__call__(*args, **kwargs)

Overloaded function.

1. __call__(self: asset.OptimalControl.InterpFunction, arg0: numpy.ndarray[numpy.float64[1, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

2. __call__(self: asset.OptimalControl.InterpFunction, arg0: asset.VectorFunctions.ScalarFunction) -> asset.VectorFunctions.VectorFunction

3. __call__(self: asset.OptimalControl.InterpFunction, arg0: asset.VectorFunctions.Element) -> asset.VectorFunctions.VectorFunction

__init__(self: asset.OptimalControl.InterpFunction, arg0: asset.OptimalControl.LGLInterpTable, arg1: numpy.ndarray[numpy.int32[m, 1]]) → None

__module__ = 'asset.OptimalControl'

adjointgradient(self: asset.OptimalControl.InterpFunction, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[m, 1]]) → numpy.ndarray[numpy.float64[1, 1]]

adjointhessian(self: asset.OptimalControl.InterpFunction, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[m, 1]]) → numpy.ndarray[numpy.float64[1, 1]]

compute(self: asset.OptimalControl.InterpFunction, arg0: numpy.ndarray[numpy.float64[1, 1]]) → numpy.ndarray[numpy.float64[m, 1]]

compute_jacobian(self: asset.OptimalControl.InterpFunction, arg0: numpy.ndarray[numpy.float64[1, 1]]) → tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]]]

computeall(self: asset.OptimalControl.InterpFunction, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[m, 1]]) → tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[1, 1]], numpy.ndarray[numpy.float64[1, 1]]]

input_domain(self: asset.OptimalControl.InterpFunction) → numpy.ndarray[numpy.int32[2, n]]

is_linear(self: asset.OptimalControl.InterpFunction) → bool

jacobian(self: asset.OptimalControl.InterpFunction, arg0: numpy.ndarray[numpy.float64[1, 1]]) → numpy.ndarray[numpy.float64[m, 1]]

name(self: asset.OptimalControl.InterpFunction) → str

rpt(self: asset.OptimalControl.InterpFunction, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: int) → None

vf(self: asset.OptimalControl.InterpFunction) → asset.VectorFunctions.VectorFunction

class asset.OptimalControl.InterpFunction_1

Bases: pybind11_object

IRows(self: asset.OptimalControl.InterpFunction_1) → int

ORows(self: asset.OptimalControl.InterpFunction_1) → int

__call__(*args, **kwargs)

Overloaded function.

1. __call__(self: asset.OptimalControl.InterpFunction_1, arg0: numpy.ndarray[numpy.float64[1, 1]]) -> numpy.ndarray[numpy.float64[1, 1]]

2. __call__(self: asset.OptimalControl.InterpFunction_1, arg0: asset.VectorFunctions.ScalarFunction) -> asset.VectorFunctions.VectorFunction

3. __call__(self: asset.OptimalControl.InterpFunction_1, arg0: asset.VectorFunctions.Element) -> asset.VectorFunctions.VectorFunction

__init__(self: asset.OptimalControl.InterpFunction_1, arg0: asset.OptimalControl.LGLInterpTable) → None

__module__ = 'asset.OptimalControl'

adjointgradient(self: asset.OptimalControl.InterpFunction_1, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[1, 1]]) → numpy.ndarray[numpy.float64[1, 1]]

adjointhessian(self: asset.OptimalControl.InterpFunction_1, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[1, 1]]) → numpy.ndarray[numpy.float64[1, 1]]

compute(self: asset.OptimalControl.InterpFunction_1, arg0: numpy.ndarray[numpy.float64[1, 1]]) → numpy.ndarray[numpy.float64[1, 1]]

compute_jacobian(self: asset.OptimalControl.InterpFunction_1, arg0: numpy.ndarray[numpy.float64[1, 1]]) → tuple[numpy.ndarray[numpy.float64[1, 1]], numpy.ndarray[numpy.float64[1, 1]]]

computeall(self: asset.OptimalControl.InterpFunction_1, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[1, 1]]) → tuple[numpy.ndarray[numpy.float64[1, 1]], numpy.ndarray[numpy.float64[1, 1]], numpy.ndarray[numpy.float64[1, 1]], numpy.ndarray[numpy.float64[1, 1]]]

input_domain(self: asset.OptimalControl.InterpFunction_1) → numpy.ndarray[numpy.int32[2, n]]

is_linear(self: asset.OptimalControl.InterpFunction_1) → bool

jacobian(self: asset.OptimalControl.InterpFunction_1, arg0: numpy.ndarray[numpy.float64[1, 1]]) → numpy.ndarray[numpy.float64[1, 1]]

name(self: asset.OptimalControl.InterpFunction_1) → str

rpt(self: asset.OptimalControl.InterpFunction_1, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: int) → None

sf(self: asset.OptimalControl.InterpFunction_1) → asset.VectorFunctions.ScalarFunction

vf(self: asset.OptimalControl.InterpFunction_1) → asset.VectorFunctions.VectorFunction

class asset.OptimalControl.InterpFunction_3

Bases: pybind11_object

IRows(self: asset.OptimalControl.InterpFunction_3) → int

ORows(self: asset.OptimalControl.InterpFunction_3) → int

__call__(*args, **kwargs)

Overloaded function.

1. __call__(self: asset.OptimalControl.InterpFunction_3, arg0: numpy.ndarray[numpy.float64[1, 1]]) -> numpy.ndarray[numpy.float64[3, 1]]

2. __call__(self: asset.OptimalControl.InterpFunction_3, arg0: asset.VectorFunctions.ScalarFunction) -> asset.VectorFunctions.VectorFunction

3. __call__(self: asset.OptimalControl.InterpFunction_3, arg0: asset.VectorFunctions.Element) -> asset.VectorFunctions.VectorFunction

__init__(self: asset.OptimalControl.InterpFunction_3, arg0: asset.OptimalControl.LGLInterpTable) → None

__module__ = 'asset.OptimalControl'

adjointgradient(self: asset.OptimalControl.InterpFunction_3, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[3, 1]]) → numpy.ndarray[numpy.float64[1, 1]]

adjointhessian(self: asset.OptimalControl.InterpFunction_3, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[3, 1]]) → numpy.ndarray[numpy.float64[1, 1]]

compute(self: asset.OptimalControl.InterpFunction_3, arg0: numpy.ndarray[numpy.float64[1, 1]]) → numpy.ndarray[numpy.float64[3, 1]]

compute_jacobian(self: asset.OptimalControl.InterpFunction_3, arg0: numpy.ndarray[numpy.float64[1, 1]]) → tuple[numpy.ndarray[numpy.float64[3, 1]], numpy.ndarray[numpy.float64[3, 1]]]

computeall(self: asset.OptimalControl.InterpFunction_3, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[3, 1]]) → tuple[numpy.ndarray[numpy.float64[3, 1]], numpy.ndarray[numpy.float64[3, 1]], numpy.ndarray[numpy.float64[1, 1]], numpy.ndarray[numpy.float64[1, 1]]]

input_domain(self: asset.OptimalControl.InterpFunction_3) → numpy.ndarray[numpy.int32[2, n]]

is_linear(self: asset.OptimalControl.InterpFunction_3) → bool

jacobian(self: asset.OptimalControl.InterpFunction_3, arg0: numpy.ndarray[numpy.float64[1, 1]]) → numpy.ndarray[numpy.float64[3, 1]]

name(self: asset.OptimalControl.InterpFunction_3) → str

rpt(self: asset.OptimalControl.InterpFunction_3, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: int) → None

vf(self: asset.OptimalControl.InterpFunction_3) → asset.VectorFunctions.VectorFunction

class asset.OptimalControl.InterpFunction_6

Bases: pybind11_object

IRows(self: asset.OptimalControl.InterpFunction_6) → int

ORows(self: asset.OptimalControl.InterpFunction_6) → int

__call__(*args, **kwargs)

Overloaded function.

1. __call__(self: asset.OptimalControl.InterpFunction_6, arg0: numpy.ndarray[numpy.float64[1, 1]]) -> numpy.ndarray[numpy.float64[6, 1]]

2. __call__(self: asset.OptimalControl.InterpFunction_6, arg0: asset.VectorFunctions.ScalarFunction) -> asset.VectorFunctions.VectorFunction

3. __call__(self: asset.OptimalControl.InterpFunction_6, arg0: asset.VectorFunctions.Element) -> asset.VectorFunctions.VectorFunction

__init__(self: asset.OptimalControl.InterpFunction_6, arg0: asset.OptimalControl.LGLInterpTable) → None

__module__ = 'asset.OptimalControl'

adjointgradient(self: asset.OptimalControl.InterpFunction_6, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[6, 1]]) → numpy.ndarray[numpy.float64[1, 1]]

adjointhessian(self: asset.OptimalControl.InterpFunction_6, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[6, 1]]) → numpy.ndarray[numpy.float64[1, 1]]

compute(self: asset.OptimalControl.InterpFunction_6, arg0: numpy.ndarray[numpy.float64[1, 1]]) → numpy.ndarray[numpy.float64[6, 1]]

compute_jacobian(self: asset.OptimalControl.InterpFunction_6, arg0: numpy.ndarray[numpy.float64[1, 1]]) → tuple[numpy.ndarray[numpy.float64[6, 1]], numpy.ndarray[numpy.float64[6, 1]]]

computeall(self: asset.OptimalControl.InterpFunction_6, arg0: numpy.ndarray[numpy.float64[1, 1]], arg1: numpy.ndarray[numpy.float64[6, 1]]) → tuple[numpy.ndarray[numpy.float64[6, 1]], numpy.ndarray[numpy.float64[6, 1]], numpy.ndarray[numpy.float64[1, 1]], numpy.ndarray[numpy.float64[1, 1]]]

input_domain(self: asset.OptimalControl.InterpFunction_6) → numpy.ndarray[numpy.int32[2, n]]

is_linear(self: asset.OptimalControl.InterpFunction_6) → bool

jacobian(self: asset.OptimalControl.InterpFunction_6, arg0: numpy.ndarray[numpy.float64[1, 1]]) → numpy.ndarray[numpy.float64[6, 1]]

name(self: asset.OptimalControl.InterpFunction_6) → str

rpt(self: asset.OptimalControl.InterpFunction_6, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: int) → None

vf(self: asset.OptimalControl.InterpFunction_6) → asset.VectorFunctions.VectorFunction

class asset.OptimalControl.LGLInterpTable

Bases: pybind11_object

ErrorIntegral(self: asset.OptimalControl.LGLInterpTable, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

InterpNonDim(self: asset.OptimalControl.LGLInterpTable, arg0: int, arg1: float, arg2: float) → list[numpy.ndarray[numpy.float64[m, 1]]]

InterpRange(self: asset.OptimalControl.LGLInterpTable, arg0: int, arg1: float, arg2: float) → list[numpy.ndarray[numpy.float64[m, 1]]]

InterpWholeRange(self: asset.OptimalControl.LGLInterpTable, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

Interpolate(self: asset.OptimalControl.LGLInterpTable, arg0: float) → numpy.ndarray[numpy.float64[m, 1]]

InterpolateDeriv(self: asset.OptimalControl.LGLInterpTable, arg0: float) → numpy.ndarray[numpy.float64[m, 2]]

NewErrorIntegral(self: asset.OptimalControl.LGLInterpTable) → list[numpy.ndarray[numpy.float64[m, 1]]]

property T0

property TF

__call__(self: asset.OptimalControl.LGLInterpTable, arg0: float) → numpy.ndarray[numpy.float64[m, 1]]

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: asset.OptimalControl.LGLInterpTable, arg0: asset.VectorFunctions.VectorFunction, arg1: int, arg2: int, arg3: asset.OptimalControl.TranscriptionModes, arg4: list[numpy.ndarray[numpy.float64[m, 1]]], arg5: int) -> None

2. __init__(self: asset.OptimalControl.LGLInterpTable, arg0: asset.VectorFunctions.VectorFunction, arg1: int, arg2: int, arg3: str, arg4: list[numpy.ndarray[numpy.float64[m, 1]]], arg5: int) -> None

3. __init__(self: asset.OptimalControl.LGLInterpTable, arg0: asset.VectorFunctions.VectorFunction, arg1: int, arg2: int, arg3: int, arg4: str, arg5: list[numpy.ndarray[numpy.float64[m, 1]]], arg6: int) -> None

4. __init__(self: asset.OptimalControl.LGLInterpTable, arg0: asset.VectorFunctions.VectorFunction, arg1: int, arg2: int, arg3: list[numpy.ndarray[numpy.float64[m, 1]]]) -> None

5. __init__(self: asset.OptimalControl.LGLInterpTable, arg0: asset.VectorFunctions.VectorFunction, arg1: int, arg2: int, arg3: int, arg4: list[numpy.ndarray[numpy.float64[m, 1]]]) -> None

6. __init__(self: asset.OptimalControl.LGLInterpTable, arg0: int, arg1: list[numpy.ndarray[numpy.float64[m, 1]]], arg2: int) -> None

7. __init__(self: asset.OptimalControl.LGLInterpTable, arg0: list[numpy.ndarray[numpy.float64[m, 1]]]) -> None

8. __init__(self: asset.OptimalControl.LGLInterpTable, arg0: asset.VectorFunctions.VectorFunction, arg1: int, arg2: int, arg3: asset.OptimalControl.TranscriptionModes) -> None

9. __init__(self: asset.OptimalControl.LGLInterpTable, arg0: int, arg1: int, arg2: asset.OptimalControl.TranscriptionModes) -> None

__module__ = 'asset.OptimalControl'

getTablePtr(self: asset.OptimalControl.LGLInterpTable) → asset.OptimalControl.LGLInterpTable

loadEvenData(self: asset.OptimalControl.LGLInterpTable, arg0: list[numpy.ndarray[numpy.float64[m, 1]]]) → None

loadUnevenData(self: asset.OptimalControl.LGLInterpTable, arg0: int, arg1: list[numpy.ndarray[numpy.float64[m, 1]]]) → None

makePeriodic(self: asset.OptimalControl.LGLInterpTable) → None

class asset.OptimalControl.LinkConstraint

Bases: pybind11_object

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: asset.OptimalControl.LinkConstraint, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> None

2. __init__(self: asset.OptimalControl.LinkConstraint, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> None

3. __init__(self: asset.OptimalControl.LinkConstraint, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> None

__module__ = 'asset.OptimalControl'

class asset.OptimalControl.LinkFlags

Bases: pybind11_object

Members:

BackToFront

BackToBack

FrontToBack

ParamsToParams

LinkParams

FrontToFront

PathToPath

BackTwoToTwoFront

FrontTwoToTwoBack

BackToBack = <LinkFlags.BackToBack: 3>

BackToFront = <LinkFlags.BackToFront: 0>

BackTwoToTwoFront = <LinkFlags.BackTwoToTwoFront: 6>

FrontToBack = <LinkFlags.FrontToBack: 1>

FrontToFront = <LinkFlags.FrontToFront: 2>

FrontTwoToTwoBack = <LinkFlags.FrontTwoToTwoBack: 7>

LinkParams = <LinkFlags.LinkParams: 5>

ParamsToParams = <LinkFlags.ParamsToParams: 4>

PathToPath = <LinkFlags.PathToPath: 8>

__eq__(self: object, other: object) → bool

__getstate__(self: object) → int

__hash__(self: object) → int

__index__(self: asset.OptimalControl.LinkFlags) → int

__init__(self: asset.OptimalControl.LinkFlags, value: int) → None

__int__(self: asset.OptimalControl.LinkFlags) → int

__members__ = {'BackToBack': <LinkFlags.BackToBack: 3>, 'BackToFront': <LinkFlags.BackToFront: 0>, 'BackTwoToTwoFront': <LinkFlags.BackTwoToTwoFront: 6>, 'FrontToBack': <LinkFlags.FrontToBack: 1>, 'FrontToFront': <LinkFlags.FrontToFront: 2>, 'FrontTwoToTwoBack': <LinkFlags.FrontTwoToTwoBack: 7>, 'LinkParams': <LinkFlags.LinkParams: 5>, 'ParamsToParams': <LinkFlags.ParamsToParams: 4>, 'PathToPath': <LinkFlags.PathToPath: 8>}

__module__ = 'asset.OptimalControl'

__ne__(self: object, other: object) → bool

__repr__(self: object) → str

__setstate__(self: asset.OptimalControl.LinkFlags, state: int) → None

__str__(self: object) → str

property name

property value

class asset.OptimalControl.LinkObjective

Bases: pybind11_object

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: asset.OptimalControl.LinkObjective, arg0: asset.VectorFunctions.ScalarFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> None

2. __init__(self: asset.OptimalControl.LinkObjective, arg0: asset.VectorFunctions.ScalarFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> None

3. __init__(self: asset.OptimalControl.LinkObjective, arg0: asset.VectorFunctions.ScalarFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> None

__module__ = 'asset.OptimalControl'

class asset.OptimalControl.MeshIterateInfo

Bases: pybind11_object

__init__(*args, **kwargs)

__module__ = 'asset.OptimalControl'

property avg_error

property converged

property distintegral

property distribution

property error

property max_error

property numsegs

property times

class asset.OptimalControl.ODEArguments

Bases: Arguments

IRows(self: asset.OptimalControl.ODEArguments) → int

ORows(self: asset.OptimalControl.ODEArguments) → int

PVar(self: asset.OptimalControl.ODEArguments, arg0: int) → asset.VectorFunctions.Element

PVec(self: asset.OptimalControl.ODEArguments) → asset.VectorFunctions.Segment

TVar(self: asset.OptimalControl.ODEArguments) → asset.VectorFunctions.Element

UVar(self: asset.OptimalControl.ODEArguments, arg0: int) → asset.VectorFunctions.Element

UVec(self: asset.OptimalControl.ODEArguments) → asset.VectorFunctions.Segment

XVar(self: asset.OptimalControl.ODEArguments, arg0: int) → asset.VectorFunctions.Element

XVec(self: asset.OptimalControl.ODEArguments) → asset.VectorFunctions.Segment

XtVec(self: asset.OptimalControl.ODEArguments) → asset.VectorFunctions.Segment

__call__(self: asset.VectorFunctions.Arguments, arg0: numpy.ndarray[numpy.float64[m, 1]]) → numpy.ndarray[numpy.float64[m, 1]]

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: asset.OptimalControl.ODEArguments, arg0: int, arg1: int, arg2: int) -> None

2. __init__(self: asset.OptimalControl.ODEArguments, arg0: int, arg1: int) -> None

3. __init__(self: asset.OptimalControl.ODEArguments, arg0: int) -> None

__module__ = 'asset.OptimalControl'

adjointgradient(self: asset.VectorFunctions.Arguments, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: numpy.ndarray[numpy.float64[m, 1]]) → numpy.ndarray[numpy.float64[m, 1]]

adjointhessian(self: asset.VectorFunctions.Arguments, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: numpy.ndarray[numpy.float64[m, 1]]) → numpy.ndarray[numpy.float64[m, n]]

compute(self: asset.VectorFunctions.Arguments, arg0: numpy.ndarray[numpy.float64[m, 1]]) → numpy.ndarray[numpy.float64[m, 1]]

compute_jacobian(self: asset.VectorFunctions.Arguments, arg0: numpy.ndarray[numpy.float64[m, 1]]) → tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, n]]]

computeall(self: asset.VectorFunctions.Arguments, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: numpy.ndarray[numpy.float64[m, 1]]) → tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, n]], numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, n]]]

input_domain(self: asset.OptimalControl.ODEArguments) → numpy.ndarray[numpy.int32[2, n]]

is_linear(self: asset.OptimalControl.ODEArguments) → bool

jacobian(self: asset.VectorFunctions.Arguments, arg0: numpy.ndarray[numpy.float64[m, 1]]) → numpy.ndarray[numpy.float64[m, n]]

name(self: asset.OptimalControl.ODEArguments) → str

rpt(self: asset.OptimalControl.ODEArguments, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: int) → None

vf(self: asset.OptimalControl.ODEArguments) → asset.VectorFunctions.VectorFunction

class asset.OptimalControl.OptimalControlProblem

Bases: OptimizationProblemBase

property AdaptiveMesh

property AutoScaling

property MaxMeshIters

property MeshAbortFlag

property MeshConverged

Phase(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → asset.OptimalControl.PhaseInterface

Gets a reference to a specific phase associated with this OCP. Allows negative indexing.

Parameters:

arg0 (int) – Index of the desired phase object.

Returns:

A reference to the desired Phase object:rtype: PhaseInterface

property Phases

A list of references to all phases associated with this OCP.

Type:

list

property PrintMeshInfo

property SolveOnlyFirst

property SyncObjectiveScales

__init__(self: asset.OptimalControl.OptimalControlProblem) → None

__module__ = 'asset.OptimalControl'

addDirectLinkEqualCon(*args, **kwargs)

Overloaded function.

1. addDirectLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, phase0: Union[int, asset.OptimalControl.PhaseInterface, str], reg0: Union[asset.OptimalControl.PhaseRegionFlags, str], v0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], phase1: Union[int, asset.OptimalControl.PhaseInterface, str], reg1: Union[asset.OptimalControl.PhaseRegionFlags, str], v1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addDirectLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.OptimalControl.LinkFlags, arg1: int, arg2: numpy.ndarray[numpy.int32[m, 1]], arg3: int, arg4: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a direct equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkFlags) – LinkFlag defining what type of link constraint

• arg1 (int) – Index of phase for the front of link equality constraint

• arg2 (Vector<int>) – Vector of indices of front phase state variables to apply link constraint to

• arg3 (int) – Index of end phase for link equality constraint

• arg2 – Vector of indices of end phase state variables to apply link constraint to

Returns:

Index of the direct equality link constraint in the optimal control problem

3. addDirectLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: int, arg2: asset.OptimalControl.PhaseRegionFlags, arg3: numpy.ndarray[numpy.int32[m, 1]], arg4: int, arg5: asset.OptimalControl.PhaseRegionFlags, arg6: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a direct equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkFlags) – LinkFlag defining what type of link constraint

• arg1 (int) – Index of phase for the front of link equality constraint

• arg2 (Vector<int>) – Vector of indices of front phase state variables to apply link constraint to

• arg3 (int) – Index of end phase for link equality constraint

• arg2 – Vector of indices of end phase state variables to apply link constraint to

Returns:

Index of the direct equality link constraint in the optimal control problem

4. addDirectLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.PhaseInterface, arg2: asset.OptimalControl.PhaseRegionFlags, arg3: numpy.ndarray[numpy.int32[m, 1]], arg4: asset.OptimalControl.PhaseInterface, arg5: asset.OptimalControl.PhaseRegionFlags, arg6: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a direct equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkFlags) – LinkFlag defining what type of link constraint

• arg1 (int) – Index of phase for the front of link equality constraint

• arg2 (Vector<int>) – Vector of indices of front phase state variables to apply link constraint to

• arg3 (int) – Index of end phase for link equality constraint

• arg2 – Vector of indices of end phase state variables to apply link constraint to

Returns:

Index of the direct equality link constraint in the optimal control problem

5. addDirectLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: int, arg2: str, arg3: numpy.ndarray[numpy.int32[m, 1]], arg4: int, arg5: str, arg6: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a direct equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkFlags) – LinkFlag defining what type of link constraint

• arg1 (int) – Index of phase for the front of link equality constraint

• arg2 (Vector<int>) – Vector of indices of front phase state variables to apply link constraint to

• arg3 (int) – Index of end phase for link equality constraint

• arg2 – Vector of indices of end phase state variables to apply link constraint to

Returns:

Index of the direct equality link constraint in the optimal control problem

6. addDirectLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.PhaseInterface, arg2: str, arg3: numpy.ndarray[numpy.int32[m, 1]], arg4: asset.OptimalControl.PhaseInterface, arg5: str, arg6: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a direct equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkFlags) – LinkFlag defining what type of link constraint

• arg1 (int) – Index of phase for the front of link equality constraint

• arg2 (Vector<int>) – Vector of indices of front phase state variables to apply link constraint to

• arg3 (int) – Index of end phase for link equality constraint

• arg2 – Vector of indices of end phase state variables to apply link constraint to

Returns:

Index of the direct equality link constraint in the optimal control problem

addForwardLinkEqualCon(*args, **kwargs)

Overloaded function.

1. addForwardLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, phase0: Union[int, asset.OptimalControl.PhaseInterface, str], phase1: Union[int, asset.OptimalControl.PhaseInterface, str], vars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> list[int]

2. addForwardLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: int, arg1: int, arg2: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a forward PhaseRegion Flag equality link constraint to the optimal control problem

Parameters:

• arg0 (int) – Index of phase for the front of link equality constraint

• arg1 (int) – Index of end phase for link equality constraint

• arg2 (Vector<int>) – Vector of indices of state variables to apply link constraint to

Returns:

Index of the forward equality link constraint in the optimal control problem

3. addForwardLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.OptimalControl.PhaseInterface, arg1: asset.OptimalControl.PhaseInterface, arg2: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a forward PhaseRegion Flag equality link constraint to the optimal control problem

Parameters:

• arg0 (int) – Index of phase for the front of link equality constraint

• arg1 (int) – Index of end phase for link equality constraint

• arg2 (Vector<int>) – Vector of indices of state variables to apply link constraint to

Returns:

Index of the forward equality link constraint in the optimal control problem

addLinkEqualCon(*args, **kwargs)

Overloaded function.

1. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.VectorFunction, phasepack: list[tuple[Union[int, asset.OptimalControl.PhaseInterface, str], Union[asset.OptimalControl.PhaseRegionFlags, str], Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]]]], linkparams: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]] = array([], dtype=int32), AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.VectorFunction, phase0: Union[int, asset.OptimalControl.PhaseInterface, str], reg0: Union[asset.OptimalControl.PhaseRegionFlags, str], XtUVars0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], phase1: Union[int, asset.OptimalControl.PhaseInterface, str], reg1: Union[asset.OptimalControl.PhaseRegionFlags, str], XtUVars1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], linkparams: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]] = array([], dtype=int32), AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.VectorFunction, phase0: Union[int, asset.OptimalControl.PhaseInterface, str], reg0: Union[asset.OptimalControl.PhaseRegionFlags, str], v0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], phase1: Union[int, asset.OptimalControl.PhaseInterface, str], reg1: Union[asset.OptimalControl.PhaseRegionFlags, str], v1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], linkparams: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]] = array([], dtype=int32), AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

4. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.OptimalControl.LinkConstraint) -> int

Adds an equality link constraint to the optimal control problem

Parameters:

arg0 (LinkConstraint) – Predefined LinkConstraint object

Returns:

Index of the equality link constraint in the optimal control problem

5. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

6. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: list[str], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

7. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

8. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: str, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

9. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

10. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: list[str], arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

11. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

12. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: str, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

13. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

Adds an equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkConstraint) – Vector of Predefined LinkConstraint object

• arg1 – Vector of PhaseRegionFlags

type arg1: PhaseRegionFlags :param arg2: Vector of phases to link. Must be same length as arg1 :param arg3: Vector of indices of state variables to link. Must be same length as arg1 :param arg4: Vector of link indices to perform phase linking. Must be same length as arg1 :returns: Index of the equality link constraint in the optimal control problem

14. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

Adds an equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkConstraint) – Vector of Predefined LinkConstraint object

• arg1 – Vector of PhaseRegionFlags

type arg1: PhaseRegionFlags :param arg2: Vector of phases to link. Must be same length as arg1 :param arg3: Vector of indices of state variables to link. Must be same length as arg1 :param arg4: Vector of link indices to perform phase linking. Must be same length as arg1 :returns: Index of the equality link constraint in the optimal control problem

15. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds an equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkConstraint) – Vector of Predefined LinkConstraint object

• arg1 – Vector of PhaseRegionFlags

type arg1: PhaseRegionFlags :param arg2: Vector of phases to link. Must be same length as arg1 :param arg3: Vector of indices of state variables to link. Must be same length as arg1 :param arg4: Vector of link indices to perform phase linking. Must be same length as arg1 :returns: Index of the equality link constraint in the optimal control problem

16. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds an equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkConstraint) – Vector of Predefined LinkConstraint object

• arg1 – Vector of PhaseRegionFlags

type arg1: PhaseRegionFlags :param arg2: Vector of phases to link. Must be same length as arg1 :param arg3: Vector of indices of state variables to link. Must be same length as arg1 :param arg4: Vector of link indices to perform phase linking. Must be same length as arg1 :returns: Index of the equality link constraint in the optimal control problem

17. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: str, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds an equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkConstraint) – Vector of Predefined LinkConstraint object

• arg1 – Vector of PhaseRegionFlags

type arg1: PhaseRegionFlags :param arg2: Vector of phases to link. Must be same length as arg1 :param arg3: Vector of indices of state variables to link. Must be same length as arg1 :param arg4: Vector of link indices to perform phase linking. Must be same length as arg1 :returns: Index of the equality link constraint in the optimal control problem

18. addLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: str, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds an equality link constraint to the optimal control problem

Parameters:

• arg0 (LinkConstraint) – Vector of Predefined LinkConstraint object

• arg1 – Vector of PhaseRegionFlags

type arg1: PhaseRegionFlags :param arg2: Vector of phases to link. Must be same length as arg1 :param arg3: Vector of indices of state variables to link. Must be same length as arg1 :param arg4: Vector of link indices to perform phase linking. Must be same length as arg1 :returns: Index of the equality link constraint in the optimal control problem

addLinkInequalCon(*args, **kwargs)

Overloaded function.

1. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.VectorFunction, phasepack: list[tuple[Union[int, asset.OptimalControl.PhaseInterface, str], Union[asset.OptimalControl.PhaseRegionFlags, str], Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]]]], linkparams: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]] = array([], dtype=int32), AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.VectorFunction, phase0: Union[int, asset.OptimalControl.PhaseInterface, str], reg0: Union[asset.OptimalControl.PhaseRegionFlags, str], XtUVars0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], phase1: Union[int, asset.OptimalControl.PhaseInterface, str], reg1: Union[asset.OptimalControl.PhaseRegionFlags, str], XtUVars1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], linkparams: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]] = array([], dtype=int32), AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.VectorFunction, phase0: Union[int, asset.OptimalControl.PhaseInterface, str], reg0: Union[asset.OptimalControl.PhaseRegionFlags, str], v0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], phase1: Union[int, asset.OptimalControl.PhaseInterface, str], reg1: Union[asset.OptimalControl.PhaseRegionFlags, str], v1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], linkparams: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]] = array([], dtype=int32), AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

4. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.OptimalControl.LinkConstraint) -> int

Adds a inequality link constraint to the optimal control problem

Parameters:

arg0 (LinkConstraint) – Fully formed LinkConstraint object

Returns:

Index of the inequality link constraint in the optimal control problem

5. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

6. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: list[str], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

7. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

8. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: str, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

9. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

10. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: list[str], arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

11. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

12. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: str, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

13. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a inequality link constraint to the optimal control problem

Parameters:

arg0 (LinkConstraint) – Fully formed LinkConstraint object

Returns:

Index of the inequality link constraint in the optimal control problem

14. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a inequality link constraint to the optimal control problem

Parameters:

arg0 (LinkConstraint) – Fully formed LinkConstraint object

Returns:

Index of the inequality link constraint in the optimal control problem

15. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: str, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a inequality link constraint to the optimal control problem

Parameters:

arg0 (LinkConstraint) – Fully formed LinkConstraint object

Returns:

Index of the inequality link constraint in the optimal control problem

16. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: str, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a inequality link constraint to the optimal control problem

Parameters:

arg0 (LinkConstraint) – Fully formed LinkConstraint object

Returns:

Index of the inequality link constraint in the optimal control problem

17. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

18. addLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

addLinkObjective(*args, **kwargs)

Overloaded function.

1. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.ScalarFunction, phasepack: list[tuple[Union[int, asset.OptimalControl.PhaseInterface, str], Union[asset.OptimalControl.PhaseRegionFlags, str], Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]]]], linkparams: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]] = array([], dtype=int32), AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.ScalarFunction, phase0: Union[int, asset.OptimalControl.PhaseInterface, str], reg0: Union[asset.OptimalControl.PhaseRegionFlags, str], XtUVars0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], phase1: Union[int, asset.OptimalControl.PhaseInterface, str], reg1: Union[asset.OptimalControl.PhaseRegionFlags, str], XtUVars1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], linkparams: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]] = array([], dtype=int32), AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.ScalarFunction, phase0: Union[int, asset.OptimalControl.PhaseInterface, str], reg0: Union[asset.OptimalControl.PhaseRegionFlags, str], v0: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], phase1: Union[int, asset.OptimalControl.PhaseInterface, str], reg1: Union[asset.OptimalControl.PhaseRegionFlags, str], v1: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], linkparams: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]] = array([], dtype=int32), AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

4. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.OptimalControl.LinkObjective) -> int

Adds a link objective to the optimal control problem

Parameters:

arg0 (LinkObjective) – Fully formed LinkObjective object

Returns:

Index of the link objective in the optimal control problem

5. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

6. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: list[str], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

7. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

8. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: str, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

9. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

10. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: list[str], arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

11. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

12. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: str, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]], arg5: list[numpy.ndarray[numpy.int32[m, 1]]], arg6: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

13. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a link objective to the optimal control problem

Parameters:

arg0 (LinkObjective) – Fully formed LinkObjective object

Returns:

Index of the link objective in the optimal control problem

14. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: asset.OptimalControl.LinkFlags, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a link objective to the optimal control problem

Parameters:

arg0 (LinkObjective) – Fully formed LinkObjective object

Returns:

Index of the link objective in the optimal control problem

15. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: str, arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a link objective to the optimal control problem

Parameters:

arg0 (LinkObjective) – Fully formed LinkObjective object

Returns:

Index of the link objective in the optimal control problem

16. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: str, arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a link objective to the optimal control problem

Parameters:

arg0 (LinkObjective) – Fully formed LinkObjective object

Returns:

Index of the link objective in the optimal control problem

17. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[numpy.ndarray[numpy.int32[m, 1]]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

Adds a link objective to the optimal control problem

Parameters:

arg0 (LinkObjective) – Fully formed LinkObjective object

Returns:

Index of the link objective in the optimal control problem

18. addLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: numpy.ndarray[numpy.uint32[m, 1]], arg2: list[list[asset.OptimalControl.PhaseInterface]], arg3: list[numpy.ndarray[numpy.int32[m, 1]]], arg4: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

Adds a link objective to the optimal control problem

Parameters:

arg0 (LinkObjective) – Fully formed LinkObjective object

Returns:

Index of the link objective in the optimal control problem

addLinkParamEqualCon(*args, **kwargs)

Overloaded function.

1. addLinkParamEqualCon(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.VectorFunction, LinkParms: list[numpy.ndarray[numpy.int32[m, 1]]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addLinkParamEqualCon(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.VectorFunction, LinkParms: numpy.ndarray[numpy.int32[m, 1]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addLinkParamEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

Adds an equality parameter link constraint to the optimal control problem with different link parameter indices

Parameters:

• arg0 – VectorFunctional defining link parameter constraint

• arg1 – Vector of vectors link parameter indices that are inputs to arg1

Returns:

Index of equality parameter link constraint in the optimal control problem

4. addLinkParamEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds an equality parameter link constraint to the optimal control problem that shares the same vector of indices for the link parameter constraint

Parameters:

• arg0 – VectorFunctional defining link parameter constraint

• arg1 – Vector of link parameter indices that are inputs to arg1

Returns:

Index of equality parameter link constraint in the optimal control problem

addLinkParamInequalCon(*args, **kwargs)

Overloaded function.

1. addLinkParamInequalCon(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.VectorFunction, LinkParms: list[numpy.ndarray[numpy.int32[m, 1]]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addLinkParamInequalCon(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.VectorFunction, LinkParms: numpy.ndarray[numpy.int32[m, 1]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addLinkParamInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

Adds an inequality parameter link constraint to the optimal control problem with different link parameter indices

Parameters:

• arg0 – VectorFunctional defining link parameter constraint

• arg1 – Vector of vectors link parameter indices that are inputs to arg1

Returns:

Index of equality parameter link constraint in the optimal control problem

4. addLinkParamInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.VectorFunction, arg1: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds an inequality parameter link constraint to the optimal control problem that shares the same vector of indices for the link parameter constraint

Parameters:

• arg0 – VectorFunctional defining link parameter constraint

• arg1 – Vector of link parameter indices that are inputs to arg1

Returns:

Index of equality parameter link constraint in the optimal control problem

addLinkParamObjective(*args, **kwargs)

Overloaded function.

1. addLinkParamObjective(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.ScalarFunction, LinkParms: list[numpy.ndarray[numpy.int32[m, 1]]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addLinkParamObjective(self: asset.OptimalControl.OptimalControlProblem, func: asset.VectorFunctions.ScalarFunction, LinkParms: numpy.ndarray[numpy.int32[m, 1]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addLinkParamObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: list[numpy.ndarray[numpy.int32[m, 1]]]) -> int

Adds a parameter link objective(s) to the optimal control problem with different link parameter indices

Parameters:

• arg0 – ScalarFunctional defining link parameter objectives

• arg1 – Vector of vectors of link parameter indices that are inputs to arg1

Returns:

Index of link parameter objective in the optimal control problem

4. addLinkParamObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.VectorFunctions.ScalarFunction, arg1: numpy.ndarray[numpy.int32[m, 1]]) -> int

Adds a parameter link objective(s) to the optimal control problem that shares the same vector of indices for the link parameter constraint

Parameters:

• arg0 – ScalarFunctional defining link parameter objectives

• arg1 – Vector of link parameter indices that are inputs to arg1

Returns:

Index of link parameter objective in the optimal control problem

addLinkParamVgroup(*args, **kwargs)

Overloaded function.

1. addLinkParamVgroup(self: asset.OptimalControl.OptimalControlProblem, arg0: numpy.ndarray[numpy.int32[m, 1]], arg1: str) -> None

2. addLinkParamVgroup(self: asset.OptimalControl.OptimalControlProblem, arg0: int, arg1: str) -> None

addLinkParamVgroups(self: asset.OptimalControl.OptimalControlProblem, arg0: dict[str, numpy.ndarray[numpy.int32[m, 1]]]) → None

addParamLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, phase0: int | asset.OptimalControl.PhaseInterface | str, phase1: int | asset.OptimalControl.PhaseInterface | str, reg0: asset.OptimalControl.PhaseRegionFlags | str, vars: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → list[int]

addPhase(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.OptimalControl.PhaseInterface) → int

Add a phase to this OCP.

Parameters:

arg0 (PhaseInterface) – The phase object you want to add

Returns:

The index of the newly added phase

Return type:

int

addPhases(self: asset.OptimalControl.OptimalControlProblem, arg0: list[asset.OptimalControl.PhaseInterface]) → list[int]

getPhaseNum(self: asset.OptimalControl.OptimalControlProblem, arg0: asset.OptimalControl.PhaseInterface) → int

removeLinkEqualCon(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → None

Discard the specified link equality constraint.

Parameters:

arg0 (int) – The index of the link equality constraint you are removing. Allows negative indexing.

Return type:

void

removeLinkInequalCon(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → None

Discard the specified link equality constraint.

Parameters:

arg0 (int) – The index of the link equality constraint you are removing. Allows negative indexing.

Return type:

void

removeLinkObjective(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → None

Discard the specified link objective.

Parameters:

arg0 (int) – The index of the link objective you are removing. Allows negative indexing.

Return type:

void

removePhase(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → None

Remove a phase from this OCP.

Parameters:

arg0 (int) – Index of the phase you want to remove

Return type:

void

returnLinkEqualConLmults(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

returnLinkEqualConScales(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → numpy.ndarray[numpy.float64[m, 1]]

returnLinkEqualConVals(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

returnLinkInequalConLmults(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

returnLinkInequalConScales(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → numpy.ndarray[numpy.float64[m, 1]]

returnLinkInequalConVals(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

returnLinkObjectiveScales(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → numpy.ndarray[numpy.float64[m, 1]]

returnLinkParams(self: asset.OptimalControl.OptimalControlProblem) → numpy.ndarray[numpy.float64[m, 1]]

Get the link parameters for this OCP.

Returns:

A numpy array of the previously specified link parameters.

setAdaptiveMesh(self: asset.OptimalControl.OptimalControlProblem, AdaptiveMesh: bool = True, ApplyToPhases: bool = True) → None

setAutoScaling(self: asset.OptimalControl.OptimalControlProblem, AutoScaling: bool = True, ApplyToPhases: bool = True) → None

setLinkParamVgroups(self: asset.OptimalControl.OptimalControlProblem, arg0: dict[str, numpy.ndarray[numpy.int32[m, 1]]]) → None

setLinkParams(*args, **kwargs)

Overloaded function.

1. setLinkParams(self: asset.OptimalControl.OptimalControlProblem, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: numpy.ndarray[numpy.float64[m, 1]]) -> None

2. setLinkParams(self: asset.OptimalControl.OptimalControlProblem, arg0: numpy.ndarray[numpy.float64[m, 1]]) -> None

Set the number and initial values of the OCP’s link parameters.

Parameters:

arg0 – Numpy array of link parameters

Return type:

void

setMaxMeshIters(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → None

setMaxSegments(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → None

setMeshErrFactor(self: asset.OptimalControl.OptimalControlProblem, arg0: float) → None

setMeshErrorCriteria(self: asset.OptimalControl.OptimalControlProblem, arg0: str) → None

setMeshErrorEstimator(self: asset.OptimalControl.OptimalControlProblem, arg0: str) → None

setMeshIncFactor(self: asset.OptimalControl.OptimalControlProblem, arg0: float) → None

setMeshRedFactor(self: asset.OptimalControl.OptimalControlProblem, arg0: float) → None

setMeshTol(self: asset.OptimalControl.OptimalControlProblem, arg0: float) → None

setMinSegments(self: asset.OptimalControl.OptimalControlProblem, arg0: int) → None

transcribe(self: asset.OptimalControl.OptimalControlProblem, arg0: bool, arg1: bool) → None

Given all phases, links, objectives, etc., construct the NonLinearProgram object that will be optimized.

Parameters:

• arg0 (bool) – Whether to print problem statistics such as the number of variables, constraints, and phases.

• arg1 (bool) – Whether to print information about the objective and constraint functions, such as the name and size.

Return type:

void

class asset.OptimalControl.PhaseInterface

Bases: OptimizationProblemBase

Base Class for All Optimal Control Phases

property AbsSwitchTol

property AdaptiveMesh

property AutoScaling

property DetectControlSwitches

property ForceOneMeshIter

property MaxMeshIters

property MeshAbortFlag

property MeshConverged

property MeshErrFactor

property MeshErrorCriteria

property MeshErrorEstimator

property MeshIncFactor

property MeshRedFactor

property MeshTol

property NewError

property NumExtraSegs

property PrintMeshInfo

property RelSwitchTol

property SolveOnlyFirst

property SyncObjectiveScales

__init__(*args, **kwargs)

__module__ = 'asset.OptimalControl'

addBoundaryValue(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, Index: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], Value: float | numpy.ndarray[numpy.float64[m, 1]], AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addDeltaTimeEqualCon(self: asset.OptimalControl.PhaseInterface, value: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addDeltaTimeObjective(self: asset.OptimalControl.PhaseInterface, Var: float, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addDeltaVarEqualCon(self: asset.OptimalControl.PhaseInterface, var: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], value: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addDeltaVarObjective(self: asset.OptimalControl.PhaseInterface, Var: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], scale: float, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addEqualCon(*args, **kwargs)

Overloaded function.

1. addEqualCon(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.VectorFunction, XtUVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addEqualCon(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.VectorFunction, InputIndex: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addEqualCon(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.StateConstraint) -> int

Adds an equality constraint to the transcription

Parameters:

arg0 – Set equality constraint with ASSET StateConstraint object

Returns:

Index of the added equality constraint in the transcription

addInequalCon(*args, **kwargs)

Overloaded function.

1. addInequalCon(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.VectorFunction, XtUVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addInequalCon(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.VectorFunction, InputIndex: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addInequalCon(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.StateConstraint) -> int

Adds an inequality constraint to the transcription

Parameters:

arg0 – ASSET StateConstraint object representing the ineqality constraint

Returns:

Index of inequality constraint in the transcription

addIntegralObjective(*args, **kwargs)

Overloaded function.

1. addIntegralObjective(self: asset.OptimalControl.PhaseInterface, Func: asset.VectorFunctions.ScalarFunction, XtUVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addIntegralObjective(self: asset.OptimalControl.PhaseInterface, Func: asset.VectorFunctions.ScalarFunction, InputIndex: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addIntegralObjective(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.StateObjective) -> int

Adds an objective that evaluates the integral of the given function over the phase

Parameters:

arg0 – ASSET StateObjective object

Returns:

Index of the integral objective

addIntegralParamFunction(*args, **kwargs)

Overloaded function.

1. addIntegralParamFunction(self: asset.OptimalControl.PhaseInterface, Func: asset.VectorFunctions.ScalarFunction, XtUVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], IntParam: int, AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addIntegralParamFunction(self: asset.OptimalControl.PhaseInterface, Func: asset.VectorFunctions.ScalarFunction, InputIndex: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], IntParam: int, AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addIntegralParamFunction(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.StateObjective, arg1: int) -> int

Adds an integral parameter constraint such that the static parameter with index ‘pv’ is equal to the integral of the given function

Parameters:

• arg0 – ASSET StateObjective object (not neccessarily an objective, but must be Scalar)

• arg1 – Index of the parameter of interest

Returns:

Index of the integral parameter constraint

addLUFuncBound(*args, **kwargs)

Overloaded function.

1. addLUFuncBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.ScalarFunction, XtUVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], lowerbound: float, upperbound: float, scale: float = 1.0, AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addLUFuncBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.ScalarFunction, XtUPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], lowerbound: float, upperbound: float, scale: float = 1.0, AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

addLUNormBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, XtUPVars: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], lowerbound: float, upperbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addLUSquaredNormBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, XtUPVars: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], lowerbound: float, upperbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addLUVarBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, var: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], lowerbound: float, upperbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addLUVarBounds(*args, **kwargs)

Overloaded function.

1. addLUVarBounds(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.PhaseRegionFlags, arg1: numpy.ndarray[numpy.int32[m, 1]], arg2: float, arg3: float, arg4: float) -> numpy.ndarray[numpy.int32[m, 1]]

Adds a lower and upper bound constraint to several variables within the transcription with a scaling term

Parameters:

• arg0 – The PhaseRegionFlag (Enumerator options = Front, Back, Path, ODEParams, StaticParams)

• arg1 – Vector of Indices of the variable to apply the bounds to (vector of int)

• arg2 – Value of constraint lower bound for all variables(double)

• arg3 – Value of constraint upper bound for all variables (double)

• arg4 – Scale value for constraint (usually 1.0)

Returns:

Vector of Indices of the upper and lower bound constraints in the transcription (vector of int)

2. addLUVarBounds(self: asset.OptimalControl.PhaseInterface, arg0: str, arg1: numpy.ndarray[numpy.int32[m, 1]], arg2: float, arg3: float, arg4: float) -> numpy.ndarray[numpy.int32[m, 1]]

Adds a lower and upper bound constraint to several variables within the transcription with a scaling term

Parameters:

• arg0 – The PhaseRegionFlag (Enumerator options = Front, Back, Path, ODEParams, StaticParams)

• arg1 – Vector of Indices of the variable to apply the bounds to (vector of int)

• arg2 – Value of constraint lower bound for all variables(double)

• arg3 – Value of constraint upper bound for all variables (double)

• arg4 – Scale value for constraint (usually 1.0)

Returns:

Vector of Indices of the upper and lower bound constraints in the transcription (vector of int)

addLowerDeltaTimeBound(self: asset.OptimalControl.PhaseInterface, lowerbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addLowerDeltaVarBound(self: asset.OptimalControl.PhaseInterface, Var: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], lowerbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addLowerFuncBound(*args, **kwargs)

Overloaded function.

1. addLowerFuncBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.ScalarFunction, XtUVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], lowerbound: float, scale: float = 1.0, AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addLowerFuncBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.ScalarFunction, XtUPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], lowerbound: float, scale: float = 1.0, AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

addLowerNormBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, XtUPVars: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], lowerbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addLowerSquaredNormBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, XtUPVars: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], lowerbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addLowerVarBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, var: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], lowerbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addPeriodicityCon(self: asset.OptimalControl.PhaseInterface, vars: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addStateObjective(*args, **kwargs)

Overloaded function.

1. addStateObjective(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.ScalarFunction, XtUVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addStateObjective(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.ScalarFunction, InputIndex: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

3. addStateObjective(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.StateObjective) -> int

Adds an objective function computable at the state/states indicated

Parameters:

arg0 – ASSET StateObjective type indicating the desired states and objective function

Returns:

Index of the state objective constraint

addStaticParamVgroup(*args, **kwargs)

Overloaded function.

1. addStaticParamVgroup(self: asset.OptimalControl.PhaseInterface, arg0: numpy.ndarray[numpy.int32[m, 1]], arg1: str) -> None

2. addStaticParamVgroup(self: asset.OptimalControl.PhaseInterface, arg0: int, arg1: str) -> None

addStaticParamVgroups(self: asset.OptimalControl.PhaseInterface, arg0: dict[str, numpy.ndarray[numpy.int32[m, 1]]]) → None

addStaticParams(*args, **kwargs)

Overloaded function.

1. addStaticParams(self: asset.OptimalControl.PhaseInterface, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: numpy.ndarray[numpy.float64[m, 1]]) -> None

2. addStaticParams(self: asset.OptimalControl.PhaseInterface, arg0: numpy.ndarray[numpy.float64[m, 1]]) -> None

addUpperDeltaTimeBound(self: asset.OptimalControl.PhaseInterface, upperbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addUpperDeltaVarBound(self: asset.OptimalControl.PhaseInterface, Var: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], upperbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addUpperFuncBound(*args, **kwargs)

Overloaded function.

1. addUpperFuncBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.ScalarFunction, XtUVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], OPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], SPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], upperbound: float, scale: float = 1.0, AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

2. addUpperFuncBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: Union[asset.OptimalControl.PhaseRegionFlags, str], Func: asset.VectorFunctions.ScalarFunction, XtUPVars: Union[int, numpy.ndarray[numpy.int32[m, 1]], str, list[str]], upperbound: float, scale: float = 1.0, AutoScale: Union[float, numpy.ndarray[numpy.float64[m, 1]], str, None] = ‘auto’) -> int

addUpperNormBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, XtUPVars: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], upperbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addUpperSquaredNormBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, XtUPVars: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], upperbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addUpperVarBound(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, var: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], upperbound: float, scale: float = 1.0, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addValueLock(self: asset.OptimalControl.PhaseInterface, reg: asset.OptimalControl.PhaseRegionFlags | str, vars: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

addValueObjective(self: asset.OptimalControl.PhaseInterface, PhaseRegion: asset.OptimalControl.PhaseRegionFlags | str, Var: int | numpy.ndarray[numpy.int32[m, 1]] | str | list[str], scale: float, AutoScale: float | numpy.ndarray[numpy.float64[m, 1]] | str | None = 'auto') → int

calc_global_error(self: asset.OptimalControl.PhaseInterface) → numpy.ndarray[numpy.float64[m, 1]]

enable_vectorization(self: asset.OptimalControl.PhaseInterface, arg0: bool) → None

getMeshInfo(self: asset.OptimalControl.PhaseInterface, arg0: bool, arg1: int) → tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]]]

getMeshIters(self: asset.OptimalControl.PhaseInterface) → list[asset.OptimalControl.MeshIterateInfo]

refineTrajAuto(self: asset.OptimalControl.PhaseInterface) → None

refineTrajEqual(self: asset.OptimalControl.PhaseInterface, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

Refine the trajectory to obtain equal error between each segment of the trajectory

Parameters:

arg0 – Number of segments to refine the trajectory (int)

Returns:

Refined trajectory (vector of states)

refineTrajManual(*args, **kwargs)

Overloaded function.

1. refineTrajManual(self: asset.OptimalControl.PhaseInterface, arg0: int) -> None

Manually refine the trajectory by modifying the number of defects per bin

Parameters:

arg0 – New number of defects per bin (int)

Returns:

void

2. refineTrajManual(self: asset.OptimalControl.PhaseInterface, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: numpy.ndarray[numpy.int32[m, 1]]) -> None

Manually refine the trajectory by modifying the bin spacing and number of defects per bin

Parameters:

• arg0 – Vector of new bin spacing (vector of double)

• arg1 – Vector of new defects per bin (vector of int)

Returns:

void

removeEqualCon(self: asset.OptimalControl.PhaseInterface, arg0: int) → None

Removes an equality constraint from the transcription

Parameters:

arg0 – Transcription index of the equality constraint to remove

Returns:

void

removeInequalCon(self: asset.OptimalControl.PhaseInterface, arg0: int) → None

Removes an inequality constraint from the transcription

Parameters:

arg0 – Transcription index of the inequality constraint to remove

Returns:

void

removeIntegralObjective(self: asset.OptimalControl.PhaseInterface, arg0: int) → None

Removes an integral objective from the transcription

Parameters:

arg0 – Transcription index of the integral objective to remove

Returns:

void

removeIntegralParamFunction(self: asset.OptimalControl.PhaseInterface, arg0: int) → None

Removes an integral parameter function from the transcription

Parameters:

arg0 – Transcription index of the integral parameter function to remove

Returns:

void

removeStateObjective(self: asset.OptimalControl.PhaseInterface, arg0: int) → None

Removes a state objective from the transcription

Parameters:

arg0 – Transcription index of the state objective to remove

Returns:

void

returnCostateTraj(self: asset.OptimalControl.PhaseInterface) → list[numpy.ndarray[numpy.float64[m, 1]]]

Returns an approximation of the costates of the trajectory (must be done after at least one solve or optimize call)

Returns:

Vector of costates and times (size xvars + 1)

returnEqualConLmults(self: asset.OptimalControl.PhaseInterface, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

Returns equality constraint lambda multipliers (must be done after at least one solve or optimize call)

Parameters:

arg0 – Index of equality constraint to obtain lambda multipliers

Returns:

Vector of lamda multipliers for trajectory equality constraints

returnEqualConScales(self: asset.OptimalControl.PhaseInterface, arg0: int) → numpy.ndarray[numpy.float64[m, 1]]

returnEqualConVals(self: asset.OptimalControl.PhaseInterface, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

returnInequalConLmults(self: asset.OptimalControl.PhaseInterface, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

Returns inequality constraint lambda multipliers (must be done after at least one solve or optimize call)

Parameters:

arg0 – Index of inequality constraint to obtain lambda multipliers

Returns:

Vector of lamda multipliers for trajectory inequality constraints

returnInequalConScales(self: asset.OptimalControl.PhaseInterface, arg0: int) → numpy.ndarray[numpy.float64[m, 1]]

returnInequalConVals(self: asset.OptimalControl.PhaseInterface, arg0: int) → list[numpy.ndarray[numpy.float64[m, 1]]]

returnIntegralObjectiveScales(self: asset.OptimalControl.PhaseInterface, arg0: int) → numpy.ndarray[numpy.float64[m, 1]]

returnIntegralParamFunctionScales(self: asset.OptimalControl.PhaseInterface, arg0: int) → numpy.ndarray[numpy.float64[m, 1]]

returnODEOutputScales(self: asset.OptimalControl.PhaseInterface) → numpy.ndarray[numpy.float64[m, 1]]

returnStateObjectiveScales(self: asset.OptimalControl.PhaseInterface, arg0: int) → numpy.ndarray[numpy.float64[m, 1]]

returnStaticParams(self: asset.OptimalControl.PhaseInterface) → numpy.ndarray[numpy.float64[m, 1]]

Returns the current active static parameters of the trajectory

Returns:

Vector of static parameters (vector of double)

returnTraj(self: asset.OptimalControl.PhaseInterface) → list[numpy.ndarray[numpy.float64[m, 1]]]

Returns the active trajectory of the transcription

returns: Vector containing states of active trajectory (vector of states)

returnTrajError(self: asset.OptimalControl.PhaseInterface) → list[numpy.ndarray[numpy.float64[m, 1]]]

returnTrajRange(self: asset.OptimalControl.PhaseInterface, arg0: int, arg1: float, arg2: float) → list[numpy.ndarray[numpy.float64[m, 1]]]

Returns active trajectory states between two times:param arg0: Number of defects to return (int) (The number of states returned is arg0*(number of states per defect)

Parameters:

• arg1 – Starting dimensional time to get states (double)

• arg2 – Final dimensional time to return states (double)

Returns:

Vector of states between times t0->tf (vector of states)

returnTrajRangeND(self: asset.OptimalControl.PhaseInterface, arg0: int, arg1: float, arg2: float) → list[numpy.ndarray[numpy.float64[m, 1]]]

Returns active trajectory states between two nondimensional times

Parameters:

• arg0 – Number of defects to return (int) (The number of states returned is arg0*(number of states per defect)

• arg1 – Starting nondimensional time to get states (double)

• arg2 – Final nondimensional time to return states (double)

Returns:

Vector of states between nondimensional times t0->tf (vector of states)

returnTrajTable(self: asset.OptimalControl.PhaseInterface) → ASSET::LGLInterpTable

returnUSplineConLmults(self: asset.OptimalControl.PhaseInterface) → list[numpy.ndarray[numpy.float64[m, 1]]]

returnUSplineConVals(self: asset.OptimalControl.PhaseInterface) → list[numpy.ndarray[numpy.float64[m, 1]]]

setAdaptiveMesh(self: asset.OptimalControl.PhaseInterface, AdaptiveMesh: bool = True) → None

setAutoScaling(self: asset.OptimalControl.PhaseInterface, AutoScaling: bool = True) → None

setControlMode(*args, **kwargs)

Overloaded function.

1. setControlMode(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.ControlModes) -> None

Set the control mode of the transcription

Parameters:

arg0 – Desired control mode (Enumerator options = HighestOrderSpline, FirstOrderSpline, NoSpline, BlockConstant)

Returns:

void

2. setControlMode(self: asset.OptimalControl.PhaseInterface, arg0: str) -> None

Set the control mode of the transcription

Parameters:

arg0 – Desired control mode (Enumerator options = HighestOrderSpline, FirstOrderSpline, NoSpline, BlockConstant)

Returns:

void

setIntegralMode(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.IntegralModes) → None

Set the integral mode of the transcription

Parameters:

arg0 – Desired integral mode (Enumerator options = BaseIntegral, SimpsonIntegral, TrapIntegral)

Returns:

void

setMaxMeshIters(self: asset.OptimalControl.PhaseInterface, arg0: int) → None

setMaxSegments(self: asset.OptimalControl.PhaseInterface, arg0: int) → None

setMeshErrFactor(self: asset.OptimalControl.PhaseInterface, arg0: float) → None

setMeshErrorCriteria(self: asset.OptimalControl.PhaseInterface, arg0: str) → None

setMeshErrorEstimator(self: asset.OptimalControl.PhaseInterface, arg0: str) → None

setMeshIncFactor(self: asset.OptimalControl.PhaseInterface, arg0: float) → None

setMeshRedFactor(self: asset.OptimalControl.PhaseInterface, arg0: float) → None

setMeshTol(self: asset.OptimalControl.PhaseInterface, arg0: float) → None

setMinSegments(self: asset.OptimalControl.PhaseInterface, arg0: int) → None

setStaticParamVgroups(self: asset.OptimalControl.PhaseInterface, arg0: dict[str, numpy.ndarray[numpy.int32[m, 1]]]) → None

setStaticParams(*args, **kwargs)

Overloaded function.

1. setStaticParams(self: asset.OptimalControl.PhaseInterface, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: numpy.ndarray[numpy.float64[m, 1]]) -> None

Set the statc paramaters of the transcription

Parameters:

arg0 – Vector of paramaters to set (vector of doubles)

Returns:

void

2. setStaticParams(self: asset.OptimalControl.PhaseInterface, arg0: numpy.ndarray[numpy.float64[m, 1]]) -> None

Set the statc paramaters of the transcription

Parameters:

arg0 – Vector of paramaters to set (vector of doubles)

Returns:

void

setTraj(*args, **kwargs)

Overloaded function.

1. setTraj(self: asset.OptimalControl.PhaseInterface, arg0: list[numpy.ndarray[numpy.float64[m, 1]]], arg1: numpy.ndarray[numpy.float64[m, 1]], arg2: numpy.ndarray[numpy.int32[m, 1]]) -> None

Set a trajectory from an existing mesh with fixed spacings and defect numbers

Parameters:

• arg0 – Full trajectory mesh to use as vector

• arg1 – Vector of spacings between bins (0 to 1) (vector of doubles)

• arg2 – Vector of size (arg1 - 1) defining number of defects per bin (vector of ints)

Returns:

void

2. setTraj(self: asset.OptimalControl.PhaseInterface, arg0: list[numpy.ndarray[numpy.float64[m, 1]]], arg1: numpy.ndarray[numpy.float64[m, 1]], arg2: numpy.ndarray[numpy.int32[m, 1]], arg3: bool) -> None

3. setTraj(self: asset.OptimalControl.PhaseInterface, arg0: list[numpy.ndarray[numpy.float64[m, 1]]], arg1: int) -> None

Set a trajectory from an existing mesh

Parameters:

• arg0 – Full trajectory mesh to use as vector

• arg1 – Vector defining number of defects per bin

Returns:

void

4. setTraj(self: asset.OptimalControl.PhaseInterface, arg0: list[numpy.ndarray[numpy.float64[m, 1]]], arg1: int, arg2: bool) -> None

5. setTraj(self: asset.OptimalControl.PhaseInterface, arg0: list[numpy.ndarray[numpy.float64[m, 1]]]) -> None

setUnits(*args, **kwargs)

Overloaded function.

1. setUnits(self: asset.OptimalControl.PhaseInterface, **kwargs) -> None

2. setUnits(self: asset.OptimalControl.PhaseInterface, arg0: numpy.ndarray[numpy.float64[m, 1]]) -> None

subStaticParams(self: asset.OptimalControl.PhaseInterface, arg0: numpy.ndarray[numpy.float64[m, 1]]) → None

Change the existing static paramaters to a new input

Parameters:

arg0 – Vector of paramaters to set (vector of doubles)

Returns:

void

subVariable(*args, **kwargs)

Overloaded function.

1. subVariable(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.PhaseRegionFlags, arg1: int, arg2: float) -> None

Switch one (1) existing variables of the transcription to a new input

Parameters:

• arg0 – Index of variable to replace

• arg1 – The PhaseRegionFlag (Enumerator options = Front, Back, Path, ODEParams, StaticParams)

• arg2 – Value of new variable

Returns:

void

2. subVariable(self: asset.OptimalControl.PhaseInterface, arg0: str, arg1: int, arg2: float) -> None

Switch one (1) existing variables of the transcription to a new input

Parameters:

• arg0 – Index of variable to replace

• arg1 – The PhaseRegionFlag (Enumerator options = Front, Back, Path, ODEParams, StaticParams)

• arg2 – Value of new variable

Returns:

void

subVariables(*args, **kwargs)

Overloaded function.

1. subVariables(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.PhaseRegionFlags, arg1: numpy.ndarray[numpy.int32[m, 1]], arg2: numpy.ndarray[numpy.float64[m, 1]]) -> None

Switch the existing variables of the transcription to a new input

Parameters:

• arg0 – The PhaseRegionFlag (Enumerator options = Front, Back, Path, ODEParams, StaticParams)

• arg1 – Vector of indices in the problem to change (vector of int)

• arg2 – Vector of values to corresponding variable indices (vector of double)

Returns:

void

2. subVariables(self: asset.OptimalControl.PhaseInterface, arg0: str, arg1: numpy.ndarray[numpy.int32[m, 1]], arg2: numpy.ndarray[numpy.float64[m, 1]]) -> None

Switch the existing variables of the transcription to a new input

Parameters:

• arg0 – The PhaseRegionFlag (Enumerator options = Front, Back, Path, ODEParams, StaticParams)

• arg1 – Vector of indices in the problem to change (vector of int)

• arg2 – Vector of values to corresponding variable indices (vector of double)

Returns:

void

switchTranscriptionMode(*args, **kwargs)

Overloaded function.

1. switchTranscriptionMode(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.TranscriptionModes, arg1: numpy.ndarray[numpy.float64[m, 1]], arg2: numpy.ndarray[numpy.int32[m, 1]]) -> None

Change the current transcription mode with fixed spacings and defect numbers

Parameters:

• arg0 – Transcription mode to change to (Enumerator)(LGL3, LGL5, LGL7, Trapezoidal, CentralShooting)

• arg1 – Vector of spacings between bins (0 to 1) (vector of doubles)

• arg2 – Vector of size (arg1 - 1) defining number of defects per bin (vector of ints)

Returns:

void

2. switchTranscriptionMode(self: asset.OptimalControl.PhaseInterface, arg0: asset.OptimalControl.TranscriptionModes) -> None

Change the current transcription mode

Parameters:

arg0 – Transcription mode to change to (Enumerator options = LGL3, LGL5, LGL7, Trapezoidal, CentralShooting)

Returns:

void

3. switchTranscriptionMode(self: asset.OptimalControl.PhaseInterface, arg0: str, arg1: numpy.ndarray[numpy.float64[m, 1]], arg2: numpy.ndarray[numpy.int32[m, 1]]) -> None

Change the current transcription mode with fixed spacings and defect numbers

Parameters:

• arg0 – Transcription mode to change to (Enumerator)(LGL3, LGL5, LGL7, Trapezoidal, CentralShooting)

• arg1 – Vector of spacings between bins (0 to 1) (vector of doubles)

• arg2 – Vector of size (arg1 - 1) defining number of defects per bin (vector of ints)

Returns:

void

4. switchTranscriptionMode(self: asset.OptimalControl.PhaseInterface, arg0: str) -> None

Change the current transcription mode

Parameters:

arg0 – Transcription mode to change to (Enumerator options = LGL3, LGL5, LGL7, Trapezoidal, CentralShooting)

Returns:

void

test_threads(self: asset.OptimalControl.PhaseInterface, arg0: int, arg1: int, arg2: int) → None

transcribe(self: asset.OptimalControl.PhaseInterface, arg0: bool, arg1: bool) → None

Force transcription. Note: this is done internally when any problem definitions are changed and usually shouldn’t be called

Parameters:

• arg0 – Displays number of variables in phase (bool)

• arg1 – Displays all functions attached to problem, along with vindices and cindeces (bool)

Returns:

void

class asset.OptimalControl.PhaseRegionFlags

Bases: pybind11_object

Members:

Front

Back

Path

NodalPath

FrontandBack

BackandFront

Params

InnerPath

ODEParams

StaticParams

PairWisePath

Back = <PhaseRegionFlags.Back: 2>

BackandFront = <PhaseRegionFlags.BackandFront: 4>

Front = <PhaseRegionFlags.Front: 1>

FrontandBack = <PhaseRegionFlags.FrontandBack: 3>

InnerPath = <PhaseRegionFlags.InnerPath: 6>

NodalPath = <PhaseRegionFlags.NodalPath: 7>

ODEParams = <PhaseRegionFlags.ODEParams: 13>

PairWisePath = <PhaseRegionFlags.PairWisePath: 9>

Params = <PhaseRegionFlags.Params: 12>

Path = <PhaseRegionFlags.Path: 5>

StaticParams = <PhaseRegionFlags.StaticParams: 14>

__eq__(self: object, other: object) → bool

__getstate__(self: object) → int

__hash__(self: object) → int

__index__(self: asset.OptimalControl.PhaseRegionFlags) → int

__init__(self: asset.OptimalControl.PhaseRegionFlags, value: int) → None

__int__(self: asset.OptimalControl.PhaseRegionFlags) → int

__members__ = {'Back': <PhaseRegionFlags.Back: 2>, 'BackandFront': <PhaseRegionFlags.BackandFront: 4>, 'Front': <PhaseRegionFlags.Front: 1>, 'FrontandBack': <PhaseRegionFlags.FrontandBack: 3>, 'InnerPath': <PhaseRegionFlags.InnerPath: 6>, 'NodalPath': <PhaseRegionFlags.NodalPath: 7>, 'ODEParams': <PhaseRegionFlags.ODEParams: 13>, 'PairWisePath': <PhaseRegionFlags.PairWisePath: 9>, 'Params': <PhaseRegionFlags.Params: 12>, 'Path': <PhaseRegionFlags.Path: 5>, 'StaticParams': <PhaseRegionFlags.StaticParams: 14>}

__module__ = 'asset.OptimalControl'

__ne__(self: object, other: object) → bool

__repr__(self: object) → str

__setstate__(self: asset.OptimalControl.PhaseRegionFlags, state: int) → None

__str__(self: object) → str

property name

property value

class asset.OptimalControl.RKOptions

Bases: pybind11_object

Members:

RK4

DOPRI54

DOPRI87

DOPRI54 = <RKOptions.DOPRI54: 2>

DOPRI87 = <RKOptions.DOPRI87: 3>

RK4 = <RKOptions.RK4: 0>

__eq__(self: object, other: object) → bool

__getstate__(self: object) → int

__hash__(self: object) → int

__index__(self: asset.OptimalControl.RKOptions) → int

__init__(self: asset.OptimalControl.RKOptions, value: int) → None

__int__(self: asset.OptimalControl.RKOptions) → int

__members__ = {'DOPRI54': <RKOptions.DOPRI54: 2>, 'DOPRI87': <RKOptions.DOPRI87: 3>, 'RK4': <RKOptions.RK4: 0>}

__module__ = 'asset.OptimalControl'

__ne__(self: object, other: object) → bool

__repr__(self: object) → str

__setstate__(self: asset.OptimalControl.RKOptions, state: int) → None

__str__(self: object) → str

property name

property value

class asset.OptimalControl.StateConstraint

Bases: pybind11_object

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: asset.OptimalControl.StateConstraint, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.PhaseRegionFlags, arg2: numpy.ndarray[numpy.int32[m, 1]], arg3: numpy.ndarray[numpy.int32[m, 1]], arg4: numpy.ndarray[numpy.int32[m, 1]]) -> None

2. __init__(self: asset.OptimalControl.StateConstraint, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.PhaseRegionFlags, arg2: numpy.ndarray[numpy.int32[m, 1]], arg3: asset.OptimalControl.PhaseRegionFlags, arg4: numpy.ndarray[numpy.int32[m, 1]]) -> None

3. __init__(self: asset.OptimalControl.StateConstraint, arg0: asset.VectorFunctions.VectorFunction, arg1: asset.OptimalControl.PhaseRegionFlags, arg2: numpy.ndarray[numpy.int32[m, 1]]) -> None

__module__ = 'asset.OptimalControl'

class asset.OptimalControl.StateObjective

Bases: pybind11_object

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: asset.OptimalControl.StateObjective, arg0: asset.VectorFunctions.ScalarFunction, arg1: asset.OptimalControl.PhaseRegionFlags, arg2: numpy.ndarray[numpy.int32[m, 1]], arg3: numpy.ndarray[numpy.int32[m, 1]], arg4: numpy.ndarray[numpy.int32[m, 1]]) -> None

2. __init__(self: asset.OptimalControl.StateObjective, arg0: asset.VectorFunctions.ScalarFunction, arg1: asset.OptimalControl.PhaseRegionFlags, arg2: numpy.ndarray[numpy.int32[m, 1]], arg3: asset.OptimalControl.PhaseRegionFlags, arg4: numpy.ndarray[numpy.int32[m, 1]]) -> None

3. __init__(self: asset.OptimalControl.StateObjective, arg0: asset.VectorFunctions.ScalarFunction, arg1: asset.OptimalControl.PhaseRegionFlags, arg2: numpy.ndarray[numpy.int32[m, 1]]) -> None

__module__ = 'asset.OptimalControl'

class asset.OptimalControl.TranscriptionModes

Bases: pybind11_object

Members:

LGL3

LGL5

LGL7

Trapezoidal

CentralShooting

CentralShooting = <TranscriptionModes.CentralShooting: 4>

LGL3 = <TranscriptionModes.LGL3: 0>

LGL5 = <TranscriptionModes.LGL5: 1>

LGL7 = <TranscriptionModes.LGL7: 2>

Trapezoidal = <TranscriptionModes.Trapezoidal: 3>

__eq__(self: object, other: object) → bool

__getstate__(self: object) → int

__hash__(self: object) → int

__index__(self: asset.OptimalControl.TranscriptionModes) → int

__init__(self: asset.OptimalControl.TranscriptionModes, value: int) → None

__int__(self: asset.OptimalControl.TranscriptionModes) → int

__members__ = {'CentralShooting': <TranscriptionModes.CentralShooting: 4>, 'LGL3': <TranscriptionModes.LGL3: 0>, 'LGL5': <TranscriptionModes.LGL5: 1>, 'LGL7': <TranscriptionModes.LGL7: 2>, 'Trapezoidal': <TranscriptionModes.Trapezoidal: 3>}

__module__ = 'asset.OptimalControl'

__ne__(self: object, other: object) → bool

__repr__(self: object) → str

__setstate__(self: asset.OptimalControl.TranscriptionModes, state: int) → None

__str__(self: object) → str

property name

property value

asset.OptimalControl.strto_PhaseRegionFlag(arg0: str) → asset.OptimalControl.PhaseRegionFlags