Python: module rosetta.core.optimization

rosetta.core.optimization

index
(built-in)

Bindings for core::optimization namespace

Modules

rosetta.core.optimization.symmetry

Classes



builtins.object

AtomTreeMinimizer
CartesianMinimizer
ConvergenceTest

DFPMinConvergedAbsolute
DFPMinConvergedFractional

DOF_DataPoint
DOF_Node
DerivCheckDataPoint
DescentDirectionAlgorithm
EItem
GA_Minimizer
JJH_Minimizer
LineMinimizationAlgorithm

ArmijoLineMinimization
BrentLineMinimization
StrongWolfeLineMinimization

Minimizer
MinimizerOptions
Multifunc

AtomTreeMultifunc

SingleResidueMultifunc

CartesianMultifunc

NelderMeadSimplex
NumericalDerivCheckResult
Particle
ParticleSwarmMinimizer
SimpleDerivCheckResult

NumDerivCheckData

func_1d
lbfgs_iteration_data

rosetta.core.kinematics.MinimizerMapBase(builtins.object)

CartesianMinimizerMap
MinimizerMap

class ArmijoLineMinimization(LineMinimizationAlgorithm)

    //////////////////////////////////////////////////////

Method resolution order:

ArmijoLineMinimization

LineMinimizationAlgorithm

builtins.object

Methods defined here:

Armijo(...) from builtins.PyCapsule
Armijo(self : rosetta.core.optimization.ArmijoLineMinimization, init_step : float, func_eval : rosetta.core.optimization.func_1d) -> float

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.ArmijoLineMinimization, curr_pos : rosetta.utility.vector1_double, curr_dir : rosetta.utility.vector1_double) -> float

__init__(...) from builtins.PyCapsule
__init__(self : handle, score_fxn : rosetta.core.optimization.Multifunc, nonmonotone : bool, dim : int) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

provide_stored_derivatives(...) from builtins.PyCapsule
provide_stored_derivatives(rosetta.core.optimization.ArmijoLineMinimization) -> bool

Methods inherited from LineMinimizationAlgorithm:

cubic_interpolation(...) from builtins.PyCapsule
cubic_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float, deriv2 : float) -> float

fetch_stored_derivatives(...) from builtins.PyCapsule
fetch_stored_derivatives(self : rosetta.core.optimization.LineMinimizationAlgorithm, get_derivs : rosetta.utility.vector1_double) -> NoneType

nonmonotone(...) from builtins.PyCapsule
nonmonotone(rosetta.core.optimization.LineMinimizationAlgorithm) -> bool

quadratic_deriv_interpolation(...) from builtins.PyCapsule
quadratic_deriv_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float, deriv2 : float) -> float

quadratic_interpolation(...) from builtins.PyCapsule
quadratic_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float) -> float

secant_interpolation(...) from builtins.PyCapsule
secant_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, deriv1 : float, point2 : float, deriv2 : float) -> float

silent(...) from builtins.PyCapsule
silent(*args, **kwargs) Overloaded function. 1. silent(rosetta.core.optimization.LineMinimizationAlgorithm) -> bool 2. silent(self : rosetta.core.optimization.LineMinimizationAlgorithm, s_in : bool) -> NoneType

store_current_derivatives(...) from builtins.PyCapsule
store_current_derivatives(self : rosetta.core.optimization.LineMinimizationAlgorithm, curr_derivs : rosetta.utility.vector1_double) -> NoneType

class AtomTreeMinimizer(builtins.object)

    High-level atom tree minimizer class

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(handle) -> NoneType 2. __init__(handle, rosetta.core.optimization.AtomTreeMinimizer) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.AtomTreeMinimizer,  : rosetta.core.optimization.AtomTreeMinimizer) -> rosetta.core.optimization.AtomTreeMinimizer

check_setup(...) from builtins.PyCapsule
check_setup(self : rosetta.core.optimization.AtomTreeMinimizer, pose : rosetta.core.pose.Pose, move_map : rosetta.core.kinematics.MoveMap, scorefxn : rosetta.core.scoring.ScoreFunction, options : core::optimization::MinimizerOptions) -> NoneType Do consistency checks for minimizer setup.

deriv_check_result(...) from builtins.PyCapsule
deriv_check_result(rosetta.core.optimization.AtomTreeMinimizer) -> core::optimization::NumericalDerivCheckResult After minimization has concluded, the user may access the deriv-check result, assuming that they have run the AtomTreeMinimizer with deriv_check = true;

run(...) from builtins.PyCapsule
run(self : rosetta.core.optimization.AtomTreeMinimizer, pose : rosetta.core.pose.Pose, move_map : rosetta.core.kinematics.MoveMap, scorefxn : rosetta.core.scoring.ScoreFunction, options : core::optimization::MinimizerOptions) -> float run minimization and return the final score at minimization's conclusion. Virtual allowing derived classes to mascarade as AtomTreeMinimizers. Non-const so that it can modify its deriv_check_result_ object.

class AtomTreeMultifunc(Multifunc)

    Atom tree multifunction class

Method resolution order:

AtomTreeMultifunc

Multifunc

builtins.object

Methods defined here:

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.AtomTreeMultifunc, vars : rosetta.utility.vector1_double) -> float

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(handle, rosetta.core.pose.Pose, core::optimization::MinimizerMap, rosetta.core.scoring.ScoreFunction) -> NoneType doc 2. __init__(handle, rosetta.core.pose.Pose, core::optimization::MinimizerMap, rosetta.core.scoring.ScoreFunction, bool) -> NoneType doc 3. __init__(self : handle, pose_in : rosetta.core.pose.Pose, min_map_in : core::optimization::MinimizerMap, scorefxn_in : rosetta.core.scoring.ScoreFunction, deriv_check_in : bool, deriv_check_verbose_in : bool) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

dfunc(...) from builtins.PyCapsule
dfunc(self : rosetta.core.optimization.AtomTreeMultifunc, vars : rosetta.utility.vector1_double, dE_dvars : rosetta.utility.vector1_double) -> NoneType

dump(...) from builtins.PyCapsule
dump(self : rosetta.core.optimization.AtomTreeMultifunc, vars : rosetta.utility.vector1_double, vars2 : rosetta.utility.vector1_double) -> NoneType Error state reached -- derivative does not match gradient

set_deriv_check_result(...) from builtins.PyCapsule
set_deriv_check_result(self : rosetta.core.optimization.AtomTreeMultifunc, deriv_check_result : core::optimization::NumericalDerivCheckResult) -> NoneType

Methods inherited from Multifunc:

abort_min(...) from builtins.PyCapsule
abort_min(self : rosetta.core.optimization.Multifunc,  : rosetta.utility.vector1_double) -> bool Christophe added the following to allow premature end of minimization If you want to abort the minimizer under specific circonstances overload this function and return true if you want to stop, false if you want to continue. FOR THE MOMENT, ONLY IN DFPMIN!

class BrentLineMinimization(LineMinimizationAlgorithm)

    //////////////////////////////////////////////////////

Method resolution order:

BrentLineMinimization

LineMinimizationAlgorithm

builtins.object

Methods defined here:

BRENT(...) from builtins.PyCapsule
BRENT(self : rosetta.core.optimization.BrentLineMinimization, AX : float, BX : float, CX : float, FA : float, FB : float, FC : float, TOL : float, func_eval : rosetta.core.optimization.func_1d) -> float

MNBRAK(...) from builtins.PyCapsule
MNBRAK(self : rosetta.core.optimization.BrentLineMinimization, AX : float, BX : float, CX : float, FA : float, FB : float, FC : float, func_eval : rosetta.core.optimization.func_1d) -> NoneType

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.BrentLineMinimization, curr_pos : rosetta.utility.vector1_double, curr_dir : rosetta.utility.vector1_double) -> float

__init__(...) from builtins.PyCapsule
__init__(self : handle, score_fxn : rosetta.core.optimization.Multifunc, dim : int) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

set_deriv_cutoff(...) from builtins.PyCapsule
set_deriv_cutoff(self : rosetta.core.optimization.BrentLineMinimization, val : float) -> NoneType

Data descriptors defined here:

deriv_cutoff_

Methods inherited from LineMinimizationAlgorithm:

cubic_interpolation(...) from builtins.PyCapsule
cubic_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float, deriv2 : float) -> float

fetch_stored_derivatives(...) from builtins.PyCapsule
fetch_stored_derivatives(self : rosetta.core.optimization.LineMinimizationAlgorithm, get_derivs : rosetta.utility.vector1_double) -> NoneType

nonmonotone(...) from builtins.PyCapsule
nonmonotone(rosetta.core.optimization.LineMinimizationAlgorithm) -> bool

provide_stored_derivatives(...) from builtins.PyCapsule
provide_stored_derivatives(rosetta.core.optimization.LineMinimizationAlgorithm) -> bool

quadratic_deriv_interpolation(...) from builtins.PyCapsule
quadratic_deriv_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float, deriv2 : float) -> float

quadratic_interpolation(...) from builtins.PyCapsule
quadratic_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float) -> float

secant_interpolation(...) from builtins.PyCapsule
secant_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, deriv1 : float, point2 : float, deriv2 : float) -> float

silent(...) from builtins.PyCapsule
silent(*args, **kwargs) Overloaded function. 1. silent(rosetta.core.optimization.LineMinimizationAlgorithm) -> bool 2. silent(self : rosetta.core.optimization.LineMinimizationAlgorithm, s_in : bool) -> NoneType

store_current_derivatives(...) from builtins.PyCapsule
store_current_derivatives(self : rosetta.core.optimization.LineMinimizationAlgorithm, curr_derivs : rosetta.utility.vector1_double) -> NoneType

class CartesianMinimizer(builtins.object)

    High-level atom tree minimizer class

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(handle) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.CartesianMinimizer,  : rosetta.core.optimization.CartesianMinimizer) -> rosetta.core.optimization.CartesianMinimizer

deriv_check_result(...) from builtins.PyCapsule
deriv_check_result(rosetta.core.optimization.CartesianMinimizer) -> core::optimization::NumericalDerivCheckResult After minimization has concluded, the user may access the deriv-check result, assuming that they have run the CartesianMinimizer with deriv_check = true;

run(...) from builtins.PyCapsule
run(self : rosetta.core.optimization.CartesianMinimizer, pose : rosetta.core.pose.Pose, move_map : rosetta.core.kinematics.MoveMap, scorefxn : rosetta.core.scoring.ScoreFunction, options : core::optimization::MinimizerOptions) -> float run minimization and return the final score at minimization's conclusion. Virtual allowing derived classes to mascarade as CartesianMinimizers. Non-const so that it can modify its deriv_check_result_ object.

class CartesianMinimizerMap(rosetta.core.kinematics.MinimizerMapBase)


Method resolution order:

CartesianMinimizerMap

rosetta.core.kinematics.MinimizerMapBase

builtins.object

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(handle) -> NoneType 2. __init__(handle, rosetta.core.optimization.CartesianMinimizerMap) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

add_atom(...) from builtins.PyCapsule
add_atom(self : rosetta.core.optimization.CartesianMinimizerMap, AtomID : rosetta.core.id.AtomID, dof_id : rosetta.core.id.DOF_ID) -> NoneType

add_torsion(...) from builtins.PyCapsule
add_torsion(self : rosetta.core.optimization.CartesianMinimizerMap, new_torsion : rosetta.core.id.DOF_ID, parent : rosetta.core.id.DOF_ID) -> NoneType

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.CartesianMinimizerMap,  : rosetta.core.optimization.CartesianMinimizerMap) -> rosetta.core.optimization.CartesianMinimizerMap

atom_derivatives(...) from builtins.PyCapsule
atom_derivatives(self : rosetta.core.optimization.CartesianMinimizerMap, resid : int) -> rosetta.utility.vector1_core_scoring_DerivVectorPair

copy_dofs_from_pose(...) from builtins.PyCapsule
copy_dofs_from_pose(self : rosetta.core.optimization.CartesianMinimizerMap, pose : rosetta.core.pose.Pose, dofs : rosetta.utility.vector1_double) -> NoneType

copy_dofs_to_pose(...) from builtins.PyCapsule
copy_dofs_to_pose(self : rosetta.core.optimization.CartesianMinimizerMap, pose : rosetta.core.pose.Pose, dofs : rosetta.utility.vector1_double) -> NoneType

domain_map(...) from builtins.PyCapsule
domain_map(rosetta.core.optimization.CartesianMinimizerMap) -> ObjexxFCL::FArray1D<int>

get_TorsionID(...) from builtins.PyCapsule
get_TorsionID(self : rosetta.core.optimization.CartesianMinimizerMap, n : int) -> rosetta.core.id.TorsionID

get_atom(...) from builtins.PyCapsule
get_atom(self : rosetta.core.optimization.CartesianMinimizerMap, n : int) -> rosetta.core.id.AtomID

get_atom_index(...) from builtins.PyCapsule
get_atom_index(self : rosetta.core.optimization.CartesianMinimizerMap, x : rosetta.core.id.AtomID) -> int

get_dof_id(...) from builtins.PyCapsule
get_dof_id(self : rosetta.core.optimization.CartesianMinimizerMap, n : int) -> rosetta.core.id.DOF_ID

natoms(...) from builtins.PyCapsule
natoms(rosetta.core.optimization.CartesianMinimizerMap) -> int

ndofs(...) from builtins.PyCapsule
ndofs(rosetta.core.optimization.CartesianMinimizerMap) -> int

ntorsions(...) from builtins.PyCapsule
ntorsions(rosetta.core.optimization.CartesianMinimizerMap) -> int

reset(...) from builtins.PyCapsule
reset(self : rosetta.core.optimization.CartesianMinimizerMap, pose : rosetta.core.pose.Pose) -> NoneType clears old data+dimensions dof_node_pointer using size data from the pose

setup(...) from builtins.PyCapsule
setup(self : rosetta.core.optimization.CartesianMinimizerMap, pose : rosetta.core.pose.Pose, move_map : rosetta.core.kinematics.MoveMap) -> NoneType

zero_stored_derivs(...) from builtins.PyCapsule
zero_stored_derivs(rosetta.core.optimization.CartesianMinimizerMap) -> NoneType

class CartesianMultifunc(Multifunc)

    Atom tree multifunction class

Method resolution order:

CartesianMultifunc

Multifunc

builtins.object

Methods defined here:

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.CartesianMultifunc, vars : rosetta.utility.vector1_double) -> float

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(handle, rosetta.core.pose.Pose, rosetta.core.optimization.CartesianMinimizerMap, rosetta.core.scoring.ScoreFunction) -> NoneType doc 2. __init__(handle, rosetta.core.pose.Pose, rosetta.core.optimization.CartesianMinimizerMap, rosetta.core.scoring.ScoreFunction, bool) -> NoneType doc 3. __init__(self : handle, pose_in : rosetta.core.pose.Pose, min_map_in : rosetta.core.optimization.CartesianMinimizerMap, scorefxn_in : rosetta.core.scoring.ScoreFunction, deriv_check_in : bool, deriv_check_verbose_in : bool) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

dfunc(...) from builtins.PyCapsule
dfunc(self : rosetta.core.optimization.CartesianMultifunc, vars : rosetta.utility.vector1_double, dE_dvars : rosetta.utility.vector1_double) -> NoneType

dump(...) from builtins.PyCapsule
dump(self : rosetta.core.optimization.CartesianMultifunc, vars : rosetta.utility.vector1_double, vars2 : rosetta.utility.vector1_double) -> NoneType Error state reached -- derivative does not match gradient

set_deriv_check_result(...) from builtins.PyCapsule
set_deriv_check_result(self : rosetta.core.optimization.CartesianMultifunc, deriv_check_result : core::optimization::NumericalDerivCheckResult) -> NoneType

Methods inherited from Multifunc:

abort_min(...) from builtins.PyCapsule
abort_min(self : rosetta.core.optimization.Multifunc,  : rosetta.utility.vector1_double) -> bool Christophe added the following to allow premature end of minimization If you want to abort the minimizer under specific circonstances overload this function and return true if you want to stop, false if you want to continue. FOR THE MOMENT, ONLY IN DFPMIN!

class ConvergenceTest(builtins.object)

    ************************************************ Rough outline of how to structure this: Make a base 'minimizer' class Sub-class into univariate and multivariate minimizers -> actually, could we treat linmin as an instance of multivariate    minimization, with a single pass of steepest descent The trick is how to mix and match convergence criteria, descent direction generation, and line minimization schemes convergence criteria could be a function or a functor.  Descent direction algorithms probably need to be functors, since they have different storage needs. ********************************************

Methods defined here:

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.ConvergenceTest, Fnew : float, Fold : float) -> bool

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.optimization.ConvergenceTest) -> NoneType 2. __init__(rosetta.core.optimization.ConvergenceTest, rosetta.core.optimization.ConvergenceTest) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.ConvergenceTest,  : rosetta.core.optimization.ConvergenceTest) -> rosetta.core.optimization.ConvergenceTest

class DFPMinConvergedAbsolute(ConvergenceTest)


Method resolution order:

DFPMinConvergedAbsolute

ConvergenceTest

builtins.object

Methods defined here:

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.DFPMinConvergedAbsolute, Fnew : float, Fold : float) -> bool

__init__(...) from builtins.PyCapsule
__init__(self : handle, _tol : float) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.DFPMinConvergedAbsolute,  : rosetta.core.optimization.DFPMinConvergedAbsolute) -> rosetta.core.optimization.DFPMinConvergedAbsolute

class DFPMinConvergedFractional(ConvergenceTest)


Method resolution order:

DFPMinConvergedFractional

ConvergenceTest

builtins.object

Methods defined here:

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.DFPMinConvergedFractional, Fnew : float, Fold : float) -> bool

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(handle, float) -> NoneType doc 2. __init__(self : handle, _tol : float, _eps : float) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.DFPMinConvergedFractional,  : rosetta.core.optimization.DFPMinConvergedFractional) -> rosetta.core.optimization.DFPMinConvergedFractional

class DOF_DataPoint(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.optimization.DOF_DataPoint) -> NoneType 2. __init__(self : rosetta.core.optimization.DOF_DataPoint, dof_id : rosetta.core.id.DOF_ID, parent_id : rosetta.core.id.DOF_ID, natoms : int, num_deriv : float, ana_deriv : float, ratio : float, f11 : float, f00 : float, f22 : float, dof_val : float) -> NoneType 3. __init__(self : rosetta.core.optimization.DOF_DataPoint,  : rosetta.core.optimization.DOF_DataPoint) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

ana_deriv(...) from builtins.PyCapsule
ana_deriv(rosetta.core.optimization.DOF_DataPoint) -> float

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.DOF_DataPoint,  : rosetta.core.optimization.DOF_DataPoint) -> rosetta.core.optimization.DOF_DataPoint

dof_id(...) from builtins.PyCapsule
dof_id(rosetta.core.optimization.DOF_DataPoint) -> rosetta.core.id.DOF_ID

dof_val(...) from builtins.PyCapsule
dof_val(rosetta.core.optimization.DOF_DataPoint) -> float

f00(...) from builtins.PyCapsule
f00(rosetta.core.optimization.DOF_DataPoint) -> float

f11(...) from builtins.PyCapsule
f11(rosetta.core.optimization.DOF_DataPoint) -> float

f22(...) from builtins.PyCapsule
f22(rosetta.core.optimization.DOF_DataPoint) -> float

natoms(...) from builtins.PyCapsule
natoms(rosetta.core.optimization.DOF_DataPoint) -> int

num_deriv(...) from builtins.PyCapsule
num_deriv(rosetta.core.optimization.DOF_DataPoint) -> float

parent_id(...) from builtins.PyCapsule
parent_id(rosetta.core.optimization.DOF_DataPoint) -> rosetta.core.id.DOF_ID

ratio(...) from builtins.PyCapsule
ratio(rosetta.core.optimization.DOF_DataPoint) -> float

class DOF_Node(builtins.object)

    Methods defined here:

F1(...) from builtins.PyCapsule
F1(*args, **kwargs) Overloaded function. 1. F1(rosetta.core.optimization.DOF_Node) -> rosetta.numeric.xyzVector_double_t 2. F1(rosetta.core.optimization.DOF_Node) -> rosetta.numeric.xyzVector_double_t

F2(...) from builtins.PyCapsule
F2(*args, **kwargs) Overloaded function. 1. F2(rosetta.core.optimization.DOF_Node) -> rosetta.numeric.xyzVector_double_t 2. F2(rosetta.core.optimization.DOF_Node) -> rosetta.numeric.xyzVector_double_t

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(self : rosetta.core.optimization.DOF_Node, id_in : rosetta.core.id.DOF_ID, parent_in : rosetta.core.optimization.DOF_Node) -> NoneType 2. __init__(self : rosetta.core.optimization.DOF_Node,  : rosetta.core.optimization.DOF_Node) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

add_atom(...) from builtins.PyCapsule
add_atom(self : rosetta.core.optimization.DOF_Node, atom : rosetta.core.id.AtomID) -> NoneType

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.DOF_Node,  : rosetta.core.optimization.DOF_Node) -> rosetta.core.optimization.DOF_Node

atom_id(...) from builtins.PyCapsule
atom_id(rosetta.core.optimization.DOF_Node) -> rosetta.core.id.AtomID

atomno(...) from builtins.PyCapsule
atomno(rosetta.core.optimization.DOF_Node) -> int

atoms(...) from builtins.PyCapsule
atoms(rosetta.core.optimization.DOF_Node) -> rosetta.utility.vector1_core_id_AtomID

clear_atoms(...) from builtins.PyCapsule
clear_atoms(rosetta.core.optimization.DOF_Node) -> NoneType

dependent(...) from builtins.PyCapsule
dependent(*args, **kwargs) Overloaded function. 1. dependent(rosetta.core.optimization.DOF_Node) -> bool 2. dependent(self : rosetta.core.optimization.DOF_Node, setting : bool) -> NoneType

depth(...) from builtins.PyCapsule
depth(rosetta.core.optimization.DOF_Node) -> int

dof_id(...) from builtins.PyCapsule
dof_id(rosetta.core.optimization.DOF_Node) -> rosetta.core.id.DOF_ID

link_vectors(...) from builtins.PyCapsule
link_vectors(rosetta.core.optimization.DOF_Node) -> NoneType sum derivative contributions down the tree

parent(...) from builtins.PyCapsule
parent(rosetta.core.optimization.DOF_Node) -> rosetta.core.optimization.DOF_Node

rsd(...) from builtins.PyCapsule
rsd(rosetta.core.optimization.DOF_Node) -> int

set_id(...) from builtins.PyCapsule
set_id(self : rosetta.core.optimization.DOF_Node, setting : rosetta.core.id.DOF_ID) -> NoneType

set_parent(...) from builtins.PyCapsule
set_parent(self : rosetta.core.optimization.DOF_Node, setting : rosetta.core.optimization.DOF_Node) -> NoneType

to_string(...) from builtins.PyCapsule
to_string(rosetta.core.optimization.DOF_Node) -> str

torsion_id(...) from builtins.PyCapsule
torsion_id(*args, **kwargs) Overloaded function. 1. torsion_id(rosetta.core.optimization.DOF_Node) -> rosetta.core.id.TorsionID get the rosetta torsion id for this DOF         This may not exist, of course. But it's useful to know what it         is when calculating derivatives of terms like rama/dunbrack/paa 2. torsion_id(self : rosetta.core.optimization.DOF_Node, id_in : rosetta.core.id.TorsionID) -> NoneType set the rosetta torsion id for this DOF         This may not exist, of course. But it's useful to know what it         is when calculating derivatives of terms like rama/dunbrack/paa

type(...) from builtins.PyCapsule
type(rosetta.core.optimization.DOF_Node) -> rosetta.core.id.DOF_Type

class DerivCheckDataPoint(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.optimization.DerivCheckDataPoint) -> NoneType 2. __init__(self : rosetta.core.optimization.DerivCheckDataPoint, num_deriv : float, ana_deriv : float, ratio : float, f11 : float, f00 : float, f22 : float, dof_val : float) -> NoneType 3. __init__(self : rosetta.core.optimization.DerivCheckDataPoint,  : rosetta.core.optimization.DerivCheckDataPoint) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

ana_deriv(...) from builtins.PyCapsule
ana_deriv(rosetta.core.optimization.DerivCheckDataPoint) -> float

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.DerivCheckDataPoint,  : rosetta.core.optimization.DerivCheckDataPoint) -> rosetta.core.optimization.DerivCheckDataPoint

dof_val(...) from builtins.PyCapsule
dof_val(rosetta.core.optimization.DerivCheckDataPoint) -> float

f00(...) from builtins.PyCapsule
f00(rosetta.core.optimization.DerivCheckDataPoint) -> float

f11(...) from builtins.PyCapsule
f11(rosetta.core.optimization.DerivCheckDataPoint) -> float

f22(...) from builtins.PyCapsule
f22(rosetta.core.optimization.DerivCheckDataPoint) -> float

num_deriv(...) from builtins.PyCapsule
num_deriv(rosetta.core.optimization.DerivCheckDataPoint) -> float

ratio(...) from builtins.PyCapsule
ratio(rosetta.core.optimization.DerivCheckDataPoint) -> float

class DescentDirectionAlgorithm(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(self : rosetta.core.optimization.DescentDirectionAlgorithm,  : rosetta.core.optimization.Multifunc) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

initialize(...) from builtins.PyCapsule
initialize(rosetta.core.optimization.DescentDirectionAlgorithm) -> NoneType

class EItem(builtins.object)

    Inner class for Genetic Algorithm, hold one population with some additional info

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.optimization.EItem) -> NoneType 2. __init__(self : rosetta.core.optimization.EItem, vn : rosetta.utility.vector1_double) -> NoneType 3. __init__(self : rosetta.core.optimization.EItem,  : rosetta.core.optimization.EItem) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

sort_R_function(...) from builtins.PyCapsule
sort_R_function(e1 : rosetta.core.optimization.EItem, e2 : rosetta.core.optimization.EItem) -> bool

Data descriptors defined here:

r

tag

v

class GA_Minimizer(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(self : rosetta.core.optimization.GA_Minimizer, func_in : rosetta.core.optimization.Multifunc, options : rosetta.core.optimization.MinimizerOptions) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

run(...) from builtins.PyCapsule
run(self : rosetta.core.optimization.GA_Minimizer, phipsi_inout : rosetta.utility.vector1_double, max_time : int) -> float

class JJH_Minimizer(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(self : rosetta.core.optimization.JJH_Minimizer, score_fxn : rosetta.core.optimization.Multifunc, line_min_alg : rosetta.core.optimization.LineMinimizationAlgorithm, converge_test : rosetta.core.optimization.ConvergenceTest, desc_dir : rosetta.core.optimization.DescentDirectionAlgorithm) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

run(...) from builtins.PyCapsule
run(self : rosetta.core.optimization.JJH_Minimizer, angles : rosetta.utility.vector1_double) -> float

class LineMinimizationAlgorithm(builtins.object)

    //////////////////////////////////////////////////////

Methods defined here:

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.LineMinimizationAlgorithm,  : rosetta.utility.vector1_double,  : rosetta.utility.vector1_double) -> float

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(self : handle, score_fxn : rosetta.core.optimization.Multifunc, dimension : int) -> NoneType 2. __init__(handle, rosetta.core.optimization.LineMinimizationAlgorithm) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

cubic_interpolation(...) from builtins.PyCapsule
cubic_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float, deriv2 : float) -> float

fetch_stored_derivatives(...) from builtins.PyCapsule
fetch_stored_derivatives(self : rosetta.core.optimization.LineMinimizationAlgorithm, get_derivs : rosetta.utility.vector1_double) -> NoneType

nonmonotone(...) from builtins.PyCapsule
nonmonotone(rosetta.core.optimization.LineMinimizationAlgorithm) -> bool

provide_stored_derivatives(...) from builtins.PyCapsule
provide_stored_derivatives(rosetta.core.optimization.LineMinimizationAlgorithm) -> bool

quadratic_deriv_interpolation(...) from builtins.PyCapsule
quadratic_deriv_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float, deriv2 : float) -> float

quadratic_interpolation(...) from builtins.PyCapsule
quadratic_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float) -> float

secant_interpolation(...) from builtins.PyCapsule
secant_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, deriv1 : float, point2 : float, deriv2 : float) -> float

silent(...) from builtins.PyCapsule
silent(*args, **kwargs) Overloaded function. 1. silent(rosetta.core.optimization.LineMinimizationAlgorithm) -> bool 2. silent(self : rosetta.core.optimization.LineMinimizationAlgorithm, s_in : bool) -> NoneType

store_current_derivatives(...) from builtins.PyCapsule
store_current_derivatives(self : rosetta.core.optimization.LineMinimizationAlgorithm, curr_derivs : rosetta.utility.vector1_double) -> NoneType

class Minimizer(builtins.object)

    Simple low-level minimizer class

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(self : rosetta.core.optimization.Minimizer, func_in : rosetta.core.optimization.Multifunc, options_in : rosetta.core.optimization.MinimizerOptions) -> NoneType 2. __init__(self : rosetta.core.optimization.Minimizer,  : rosetta.core.optimization.Minimizer) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

run(...) from builtins.PyCapsule
run(self : rosetta.core.optimization.Minimizer, phipsi_inout : rosetta.utility.vector1_double) -> float

class MinimizerMap(rosetta.core.kinematics.MinimizerMapBase)


Method resolution order:

MinimizerMap

rosetta.core.kinematics.MinimizerMapBase

builtins.object

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(handle) -> NoneType 2. __init__(handle, rosetta.core.optimization.MinimizerMap) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

add_atom(...) from builtins.PyCapsule
add_atom(self : rosetta.core.optimization.MinimizerMap, atom_id : rosetta.core.id.AtomID, dof_id : rosetta.core.id.DOF_ID) -> NoneType

add_torsion(...) from builtins.PyCapsule
add_torsion(self : rosetta.core.optimization.MinimizerMap, new_torsion : rosetta.core.id.DOF_ID, parent : rosetta.core.id.DOF_ID) -> NoneType

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.MinimizerMap,  : rosetta.core.optimization.MinimizerMap) -> rosetta.core.optimization.MinimizerMap

atom_derivatives(...) from builtins.PyCapsule
atom_derivatives(self : rosetta.core.optimization.MinimizerMap, resid : int) -> rosetta.utility.vector1_core_scoring_DerivVectorPair

begin(...) from builtins.PyCapsule
begin(*args, **kwargs) Overloaded function. 1. begin(rosetta.core.optimization.MinimizerMap) -> std::_List_const_iterator<std::shared_ptr<core::optimization::DOF_Node> > 2. begin(rosetta.core.optimization.MinimizerMap) -> std::_List_iterator<std::shared_ptr<core::optimization::DOF_Node> >

copy_dofs_from_pose(...) from builtins.PyCapsule
copy_dofs_from_pose(self : rosetta.core.optimization.MinimizerMap, pose : rosetta.core.pose.Pose, dofs : rosetta.utility.vector1_double) -> NoneType

copy_dofs_to_pose(...) from builtins.PyCapsule
copy_dofs_to_pose(self : rosetta.core.optimization.MinimizerMap, pose : rosetta.core.pose.Pose, dofs : rosetta.utility.vector1_double) -> NoneType

dof_node_from_id(...) from builtins.PyCapsule
dof_node_from_id(self : rosetta.core.optimization.MinimizerMap, id : rosetta.core.id.DOF_ID) -> rosetta.core.optimization.DOF_Node get a dof_node by its dof_id

dof_nodes(...) from builtins.PyCapsule
dof_nodes(*args, **kwargs) Overloaded function. 1. dof_nodes(rosetta.core.optimization.MinimizerMap) -> rosetta.std.list_std_shared_ptr_core_optimization_DOF_Node_std_allocator_std_shared_ptr_core_optimization_DOF_Node_t 2. dof_nodes(rosetta.core.optimization.MinimizerMap) -> rosetta.std.list_std_shared_ptr_core_optimization_DOF_Node_std_allocator_std_shared_ptr_core_optimization_DOF_Node_t

domain_map(...) from builtins.PyCapsule
domain_map(rosetta.core.optimization.MinimizerMap) -> ObjexxFCL::FArray1D<int>

end(...) from builtins.PyCapsule
end(*args, **kwargs) Overloaded function. 1. end(rosetta.core.optimization.MinimizerMap) -> std::_List_const_iterator<std::shared_ptr<core::optimization::DOF_Node> > 2. end(rosetta.core.optimization.MinimizerMap) -> std::_List_iterator<std::shared_ptr<core::optimization::DOF_Node> >

link_torsion_vectors(...) from builtins.PyCapsule
link_torsion_vectors(rosetta.core.optimization.MinimizerMap) -> NoneType this will only work if DOF_nodes are sorted!

nangles(...) from builtins.PyCapsule
nangles(rosetta.core.optimization.MinimizerMap) -> int

reset(...) from builtins.PyCapsule
reset(self : rosetta.core.optimization.MinimizerMap, pose : rosetta.core.pose.Pose) -> NoneType clears old data+dimensions dof_node_pointer using size data from the pose

reset_jump_rb_deltas(...) from builtins.PyCapsule
reset_jump_rb_deltas(self : rosetta.core.optimization.MinimizerMap, pose : rosetta.core.pose.Pose, dofs : rosetta.utility.vector1_double) -> NoneType

setup(...) from builtins.PyCapsule
setup(self : rosetta.core.optimization.MinimizerMap, pose : rosetta.core.pose.Pose, move_map : rosetta.core.kinematics.MoveMap) -> NoneType

torsion_scale_factor(...) from builtins.PyCapsule
torsion_scale_factor(self : rosetta.core.optimization.MinimizerMap, tor : rosetta.core.optimization.DOF_Node) -> float

zero_torsion_vectors(...) from builtins.PyCapsule
zero_torsion_vectors(rosetta.core.optimization.MinimizerMap) -> NoneType

class MinimizerOptions(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.optimization.MinimizerOptions, str, float, bool) -> NoneType doc 2. __init__(rosetta.core.optimization.MinimizerOptions, str, float, bool, bool) -> NoneType doc 3. __init__(self : rosetta.core.optimization.MinimizerOptions, min_type_in : str, minimize_tolerance_in : float, use_nblist_in : bool, deriv_check_in : bool, deriv_check_verbose_in : bool) -> NoneType 4. __init__(self : rosetta.core.optimization.MinimizerOptions,  : rosetta.core.optimization.MinimizerOptions) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.MinimizerOptions,  : rosetta.core.optimization.MinimizerOptions) -> rosetta.core.optimization.MinimizerOptions

ax_init(...) from builtins.PyCapsule
ax_init(rosetta.core.optimization.MinimizerOptions) -> float //////////////////////////////////////////////////////////////////////////

brent_abs_tolerance(...) from builtins.PyCapsule
brent_abs_tolerance(rosetta.core.optimization.MinimizerOptions) -> float

bx_init(...) from builtins.PyCapsule
bx_init(rosetta.core.optimization.MinimizerOptions) -> float

clone(...) from builtins.PyCapsule
clone(rosetta.core.optimization.MinimizerOptions) -> rosetta.core.optimization.MinimizerOptions

deriv_check(...) from builtins.PyCapsule
deriv_check(*args, **kwargs) Overloaded function. 1. deriv_check(self : rosetta.core.optimization.MinimizerOptions, deriv_check_in : bool) -> NoneType 2. deriv_check(rosetta.core.optimization.MinimizerOptions) -> bool

deriv_check_to_stdout(...) from builtins.PyCapsule
deriv_check_to_stdout(*args, **kwargs) Overloaded function. 1. deriv_check_to_stdout(self : rosetta.core.optimization.MinimizerOptions, setting : bool) -> NoneType 2. deriv_check_to_stdout(rosetta.core.optimization.MinimizerOptions) -> bool

deriv_check_verbose(...) from builtins.PyCapsule
deriv_check_verbose(rosetta.core.optimization.MinimizerOptions) -> bool

ga_mutation_probability(...) from builtins.PyCapsule
ga_mutation_probability(*args, **kwargs) Overloaded function. 1. ga_mutation_probability(rosetta.core.optimization.MinimizerOptions) -> float 2. ga_mutation_probability(self : rosetta.core.optimization.MinimizerOptions, p : float) -> NoneType

gmax_cutoff_for_convergence(...) from builtins.PyCapsule
gmax_cutoff_for_convergence(*args, **kwargs) Overloaded function. 1. gmax_cutoff_for_convergence(rosetta.core.optimization.MinimizerOptions) -> float 2. gmax_cutoff_for_convergence(self : rosetta.core.optimization.MinimizerOptions, gmax_in : float) -> NoneType

linmin_deriv_cutoff(...) from builtins.PyCapsule
linmin_deriv_cutoff(*args, **kwargs) Overloaded function. 1. linmin_deriv_cutoff(rosetta.core.optimization.MinimizerOptions) -> float The derivative cutoff used for Brent. 2. linmin_deriv_cutoff(self : rosetta.core.optimization.MinimizerOptions, val : float) -> NoneType Set the derivative cutoff used for Brent.

max_iter(...) from builtins.PyCapsule
max_iter(*args, **kwargs) Overloaded function. 1. max_iter(rosetta.core.optimization.MinimizerOptions) -> int 2. max_iter(self : rosetta.core.optimization.MinimizerOptions, n : int) -> NoneType

min_type(...) from builtins.PyCapsule
min_type(*args, **kwargs) Overloaded function. 1. min_type(rosetta.core.optimization.MinimizerOptions) -> str ////////////////////////////////////////////////////////////////////////// 2. min_type(self : rosetta.core.optimization.MinimizerOptions, min_type_in : str) -> NoneType 3. min_type(rosetta.core.optimization.MinimizerOptions) -> str

minimize_tolerance(...) from builtins.PyCapsule
minimize_tolerance(*args, **kwargs) Overloaded function. 1. minimize_tolerance(rosetta.core.optimization.MinimizerOptions) -> float 2. minimize_tolerance(rosetta.core.optimization.MinimizerOptions) -> float 3. minimize_tolerance(self : rosetta.core.optimization.MinimizerOptions, minimize_tolerance_in : float) -> NoneType

nblist_auto_update(...) from builtins.PyCapsule
nblist_auto_update(*args, **kwargs) Overloaded function. 1. nblist_auto_update(rosetta.core.optimization.MinimizerOptions) -> bool 2. nblist_auto_update(self : rosetta.core.optimization.MinimizerOptions, setting : bool) -> NoneType

silent(...) from builtins.PyCapsule
silent(*args, **kwargs) Overloaded function. 1. silent(rosetta.core.optimization.MinimizerOptions) -> bool 2. silent(self : rosetta.core.optimization.MinimizerOptions, silent_in : bool) -> NoneType

use_nblist(...) from builtins.PyCapsule
use_nblist(*args, **kwargs) Overloaded function. 1. use_nblist(rosetta.core.optimization.MinimizerOptions) -> bool Indicate whether or not a handful of optimizations regarding the neighbor list have been enabled.   use_nblist() 2. use_nblist(self : rosetta.core.optimization.MinimizerOptions, use_nblist_in : bool) -> NoneType Indicate whether or not a handful of optimizations regarding the neighbor list should be enabled. The neighbor list is based on the move map.  It includes any atoms that can be moved by the minimizer plus their neighbors.  This list is not updated during minimization.  All scores for atoms and atom pairs outside the neighbor list are held fixed.  All scores for atoms and atom pairs within the list are not cached (usually they would be), since it assumed that they will be changing rapidly.  These optimizations are effective when a large number of small moves are being made.  You may prefer to enable this option when minimizing in fullatom mode, and to disable it in centroid mode. I wrote this docstring after I reading through a bunch of code to figure out what this option meant, but I don't have any expertise with the minimizer.  So the above represents my understanding of this option, but there could very well be errors or misstatements. core::scoring::AtomNeighbor

xx_init(...) from builtins.PyCapsule
xx_init(rosetta.core.optimization.MinimizerOptions) -> float

class Multifunc(builtins.object)

    Multifunction interface class

Methods defined here:

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.Multifunc, phipsi : rosetta.utility.vector1_double) -> float

__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

abort_min(...) from builtins.PyCapsule
abort_min(self : rosetta.core.optimization.Multifunc,  : rosetta.utility.vector1_double) -> bool Christophe added the following to allow premature end of minimization If you want to abort the minimizer under specific circonstances overload this function and return true if you want to stop, false if you want to continue. FOR THE MOMENT, ONLY IN DFPMIN!

dfunc(...) from builtins.PyCapsule
dfunc(self : rosetta.core.optimization.Multifunc, phipsi : rosetta.utility.vector1_double, dE_dphipsi : rosetta.utility.vector1_double) -> NoneType

dump(...) from builtins.PyCapsule
dump(self : rosetta.core.optimization.Multifunc,  : rosetta.utility.vector1_double,  : rosetta.utility.vector1_double) -> NoneType Error state reached -- derivative does not match gradient Derived classes have the oportunity to now output and or analyze the two vars assignments vars, vars+delta where the derivatives are incorrect.

class NelderMeadSimplex(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(self : rosetta.core.optimization.NelderMeadSimplex, func_in : rosetta.core.optimization.Multifunc, options_in : rosetta.core.optimization.MinimizerOptions) -> NoneType 2. __init__(self : rosetta.core.optimization.NelderMeadSimplex,  : rosetta.core.optimization.NelderMeadSimplex) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

run(...) from builtins.PyCapsule
run(self : rosetta.core.optimization.NelderMeadSimplex, phipsi_inout : rosetta.utility.vector1_double, upperbound : rosetta.utility.vector1_double) -> float

Data descriptors defined here:

options_

class NumDerivCheckData(SimpleDerivCheckResult)


Method resolution order:

NumDerivCheckData

SimpleDerivCheckResult

builtins.object

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(self : rosetta.core.optimization.NumDerivCheckData, nangles : int, nsteps : int) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.NumDerivCheckData,  : rosetta.core.optimization.NumDerivCheckData) -> rosetta.core.optimization.NumDerivCheckData

dof_step_data(...) from builtins.PyCapsule
dof_step_data(*args, **kwargs) Overloaded function. 1. dof_step_data(self : rosetta.core.optimization.NumDerivCheckData, dof_ind : int, step_ind : int, dofdp : rosetta.core.optimization.DOF_DataPoint) -> NoneType 2. dof_step_data(self : rosetta.core.optimization.NumDerivCheckData, dof_ind : int, step_ind : int) -> rosetta.core.optimization.DOF_DataPoint

Methods inherited from SimpleDerivCheckResult:

abs_deriv_dev(...) from builtins.PyCapsule
abs_deriv_dev(*args, **kwargs) Overloaded function. 1. abs_deriv_dev(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int, val : float) -> NoneType 2. abs_deriv_dev(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int) -> float

best_abs_log_norm_ratio(...) from builtins.PyCapsule
best_abs_log_norm_ratio(*args, **kwargs) Overloaded function. 1. best_abs_log_norm_ratio(self : rosetta.core.optimization.SimpleDerivCheckResult, val : float) -> NoneType 2. best_abs_log_norm_ratio(rosetta.core.optimization.SimpleDerivCheckResult) -> float

best_cos_theta(...) from builtins.PyCapsule
best_cos_theta(*args, **kwargs) Overloaded function. 1. best_cos_theta(self : rosetta.core.optimization.SimpleDerivCheckResult, val : float) -> NoneType 2. best_cos_theta(rosetta.core.optimization.SimpleDerivCheckResult) -> float

best_norm_analytic(...) from builtins.PyCapsule
best_norm_analytic(*args, **kwargs) Overloaded function. 1. best_norm_analytic(self : rosetta.core.optimization.SimpleDerivCheckResult, val : float) -> NoneType 2. best_norm_analytic(rosetta.core.optimization.SimpleDerivCheckResult) -> float

best_norm_numeric(...) from builtins.PyCapsule
best_norm_numeric(*args, **kwargs) Overloaded function. 1. best_norm_numeric(self : rosetta.core.optimization.SimpleDerivCheckResult, val : float) -> NoneType 2. best_norm_numeric(rosetta.core.optimization.SimpleDerivCheckResult) -> float

nangles(...) from builtins.PyCapsule
nangles(rosetta.core.optimization.SimpleDerivCheckResult) -> int

nsteps(...) from builtins.PyCapsule
nsteps(rosetta.core.optimization.SimpleDerivCheckResult) -> int

rel_deriv_dev(...) from builtins.PyCapsule
rel_deriv_dev(*args, **kwargs) Overloaded function. 1. rel_deriv_dev(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int, val : float) -> NoneType 2. rel_deriv_dev(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int) -> float

step_data(...) from builtins.PyCapsule
step_data(*args, **kwargs) Overloaded function. 1. step_data(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int, step_ind : int, dp : rosetta.core.optimization.DerivCheckDataPoint) -> NoneType 2. step_data(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int, step_ind : int) -> rosetta.core.optimization.DerivCheckDataPoint

class NumericalDerivCheckResult(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(rosetta.core.optimization.NumericalDerivCheckResult) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

add_deriv_data(...) from builtins.PyCapsule
add_deriv_data(self : rosetta.core.optimization.NumericalDerivCheckResult, deriv_check_data : rosetta.core.optimization.NumDerivCheckData) -> NoneType

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.NumericalDerivCheckResult,  : rosetta.core.optimization.NumericalDerivCheckResult) -> rosetta.core.optimization.NumericalDerivCheckResult

deriv_check_result(...) from builtins.PyCapsule
deriv_check_result(self : rosetta.core.optimization.NumericalDerivCheckResult, ind : int) -> rosetta.core.optimization.NumDerivCheckData

n_deriv_check_results(...) from builtins.PyCapsule
n_deriv_check_results(rosetta.core.optimization.NumericalDerivCheckResult) -> int

send_to_stdout(...) from builtins.PyCapsule
send_to_stdout(*args, **kwargs) Overloaded function. 1. send_to_stdout(self : rosetta.core.optimization.NumericalDerivCheckResult, setting : bool) -> NoneType 2. send_to_stdout(rosetta.core.optimization.NumericalDerivCheckResult) -> bool

class Particle(builtins.object)

    Simple data container for PSO algorithm.

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(self : rosetta.core.optimization.Particle, size : int) -> NoneType 2. __init__(self : rosetta.core.optimization.Particle, p_in : rosetta.utility.vector1_double) -> NoneType 3. __init__(self : rosetta.core.optimization.Particle,  : rosetta.core.optimization.Particle) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

__str__(...) from builtins.PyCapsule
__str__(rosetta.core.optimization.Particle) -> str

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.Particle,  : rosetta.core.optimization.Particle) -> rosetta.core.optimization.Particle

ensure_size(...) from builtins.PyCapsule
ensure_size(self : rosetta.core.optimization.Particle, minsize : int) -> NoneType Make sure that all arrays are large enough -- prevents index-out-of-bound errors.

fitness_pbest(...) from builtins.PyCapsule
fitness_pbest(rosetta.core.optimization.Particle) -> float

pbest(...) from builtins.PyCapsule
pbest(rosetta.core.optimization.Particle) -> rosetta.utility.vector1_double This is why data should be private: you get to ensure it's valid when you read it.

score(...) from builtins.PyCapsule
score(self : rosetta.core.optimization.Particle, f : rosetta.core.optimization.Multifunc) -> float

set_score(...) from builtins.PyCapsule
set_score(self : rosetta.core.optimization.Particle, new_score : float) -> float

Data descriptors defined here:

fitness_

p_

v_

class ParticleSwarmMinimizer(builtins.object)

    Particle Swarm Optimization engine. Algorithm details based heavily on     Chen, Liu, Huang, Hwang, Ho (2006).     "SODOCK:  Swarm Optimization for Highly Flexible Protein-Ligand Docking"     J Comput Chem 28: 612-623, 2007 Also on     http://en.wikipedia.org/wiki/Particle_swarm_optimization     http://www.swarmintelligence.org/ One can imagine writing another version that distributed the work via MPI...

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(self : rosetta.core.optimization.ParticleSwarmMinimizer, p_min : rosetta.utility.vector1_double, p_max : rosetta.utility.vector1_double) -> NoneType 2. __init__(self : rosetta.core.optimization.ParticleSwarmMinimizer,  : rosetta.core.optimization.ParticleSwarmMinimizer) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.ParticleSwarmMinimizer,  : rosetta.core.optimization.ParticleSwarmMinimizer) -> rosetta.core.optimization.ParticleSwarmMinimizer

class SimpleDerivCheckResult(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(self : rosetta.core.optimization.SimpleDerivCheckResult, nangles : int, nsteps : int) -> NoneType 2. __init__(self : rosetta.core.optimization.SimpleDerivCheckResult,  : rosetta.core.optimization.SimpleDerivCheckResult) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

abs_deriv_dev(...) from builtins.PyCapsule
abs_deriv_dev(*args, **kwargs) Overloaded function. 1. abs_deriv_dev(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int, val : float) -> NoneType 2. abs_deriv_dev(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int) -> float

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.optimization.SimpleDerivCheckResult,  : rosetta.core.optimization.SimpleDerivCheckResult) -> rosetta.core.optimization.SimpleDerivCheckResult

best_abs_log_norm_ratio(...) from builtins.PyCapsule
best_abs_log_norm_ratio(*args, **kwargs) Overloaded function. 1. best_abs_log_norm_ratio(self : rosetta.core.optimization.SimpleDerivCheckResult, val : float) -> NoneType 2. best_abs_log_norm_ratio(rosetta.core.optimization.SimpleDerivCheckResult) -> float

best_cos_theta(...) from builtins.PyCapsule
best_cos_theta(*args, **kwargs) Overloaded function. 1. best_cos_theta(self : rosetta.core.optimization.SimpleDerivCheckResult, val : float) -> NoneType 2. best_cos_theta(rosetta.core.optimization.SimpleDerivCheckResult) -> float

best_norm_analytic(...) from builtins.PyCapsule
best_norm_analytic(*args, **kwargs) Overloaded function. 1. best_norm_analytic(self : rosetta.core.optimization.SimpleDerivCheckResult, val : float) -> NoneType 2. best_norm_analytic(rosetta.core.optimization.SimpleDerivCheckResult) -> float

best_norm_numeric(...) from builtins.PyCapsule
best_norm_numeric(*args, **kwargs) Overloaded function. 1. best_norm_numeric(self : rosetta.core.optimization.SimpleDerivCheckResult, val : float) -> NoneType 2. best_norm_numeric(rosetta.core.optimization.SimpleDerivCheckResult) -> float

nangles(...) from builtins.PyCapsule
nangles(rosetta.core.optimization.SimpleDerivCheckResult) -> int

nsteps(...) from builtins.PyCapsule
nsteps(rosetta.core.optimization.SimpleDerivCheckResult) -> int

rel_deriv_dev(...) from builtins.PyCapsule
rel_deriv_dev(*args, **kwargs) Overloaded function. 1. rel_deriv_dev(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int, val : float) -> NoneType 2. rel_deriv_dev(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int) -> float

step_data(...) from builtins.PyCapsule
step_data(*args, **kwargs) Overloaded function. 1. step_data(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int, step_ind : int, dp : rosetta.core.optimization.DerivCheckDataPoint) -> NoneType 2. step_data(self : rosetta.core.optimization.SimpleDerivCheckResult, dof_ind : int, step_ind : int) -> rosetta.core.optimization.DerivCheckDataPoint

class SingleResidueMultifunc(AtomTreeMultifunc)

    A streamlined AtomTreeMultifunc designed specifically for RTMIN. Evaluates only the energies between the specified residue and the rest of the Pose, assuming the nbr_atoms do not move (as in rotamer trials and repacking). Could probably be sped up further with a customized dfunc(). DFPMIN seems to spend most of its time in func() rather than dfunc(), so there's not as much to gain there anyway.

Method resolution order:

SingleResidueMultifunc

AtomTreeMultifunc

Multifunc

builtins.object

Methods defined here:

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.SingleResidueMultifunc, vars : rosetta.utility.vector1_double) -> float

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(handle, rosetta.core.pose.Pose, int, rosetta.core.optimization.MinimizerMap, rosetta.core.scoring.ScoreFunction, rosetta.core.graph.Graph) -> NoneType doc 2. __init__(handle, rosetta.core.pose.Pose, int, rosetta.core.optimization.MinimizerMap, rosetta.core.scoring.ScoreFunction, rosetta.core.graph.Graph, bool) -> NoneType doc 3. __init__(self : handle, pose_in : rosetta.core.pose.Pose, rsd_id_in : int, min_map_in : rosetta.core.optimization.MinimizerMap, scorefxn_in : rosetta.core.scoring.ScoreFunction, packer_neighbor_graph_in : rosetta.core.graph.Graph, deriv_check_in : bool, deriv_check_verbose_in : bool) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

Methods inherited from AtomTreeMultifunc:

dfunc(...) from builtins.PyCapsule
dfunc(self : rosetta.core.optimization.AtomTreeMultifunc, vars : rosetta.utility.vector1_double, dE_dvars : rosetta.utility.vector1_double) -> NoneType

dump(...) from builtins.PyCapsule
dump(self : rosetta.core.optimization.AtomTreeMultifunc, vars : rosetta.utility.vector1_double, vars2 : rosetta.utility.vector1_double) -> NoneType Error state reached -- derivative does not match gradient

set_deriv_check_result(...) from builtins.PyCapsule
set_deriv_check_result(self : rosetta.core.optimization.AtomTreeMultifunc, deriv_check_result : core::optimization::NumericalDerivCheckResult) -> NoneType

Methods inherited from Multifunc:

abort_min(...) from builtins.PyCapsule
abort_min(self : rosetta.core.optimization.Multifunc,  : rosetta.utility.vector1_double) -> bool Christophe added the following to allow premature end of minimization If you want to abort the minimizer under specific circonstances overload this function and return true if you want to stop, false if you want to continue. FOR THE MOMENT, ONLY IN DFPMIN!

class StrongWolfeLineMinimization(LineMinimizationAlgorithm)

    //////////////////////////////////////////////////////

Method resolution order:

StrongWolfeLineMinimization

LineMinimizationAlgorithm

builtins.object

Methods defined here:

StrongWolfe(...) from builtins.PyCapsule
StrongWolfe(self : rosetta.core.optimization.StrongWolfeLineMinimization, init_step : float, func_eval : rosetta.core.optimization.func_1d) -> float

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.StrongWolfeLineMinimization, curr_pos : rosetta.utility.vector1_double, curr_dir : rosetta.utility.vector1_double) -> float

__init__(...) from builtins.PyCapsule
__init__(self : handle, score_fxn : rosetta.core.optimization.Multifunc, nonmonotone : bool, dim : int) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

provide_stored_derivatives(...) from builtins.PyCapsule
provide_stored_derivatives(rosetta.core.optimization.StrongWolfeLineMinimization) -> bool

zoom(...) from builtins.PyCapsule
zoom(self : rosetta.core.optimization.StrongWolfeLineMinimization, alpha_low : float, func_low : float, deriv_low : float, alpha_high : float, func_high : float, deriv_high : float, func_zero : float, deriv_zero : float, func_return : float, func_eval : rosetta.core.optimization.func_1d) -> float

Methods inherited from LineMinimizationAlgorithm:

cubic_interpolation(...) from builtins.PyCapsule
cubic_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float, deriv2 : float) -> float

fetch_stored_derivatives(...) from builtins.PyCapsule
fetch_stored_derivatives(self : rosetta.core.optimization.LineMinimizationAlgorithm, get_derivs : rosetta.utility.vector1_double) -> NoneType

nonmonotone(...) from builtins.PyCapsule
nonmonotone(rosetta.core.optimization.LineMinimizationAlgorithm) -> bool

quadratic_deriv_interpolation(...) from builtins.PyCapsule
quadratic_deriv_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float, deriv2 : float) -> float

quadratic_interpolation(...) from builtins.PyCapsule
quadratic_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, func1 : float, deriv1 : float, point2 : float, func2 : float) -> float

secant_interpolation(...) from builtins.PyCapsule
secant_interpolation(self : rosetta.core.optimization.LineMinimizationAlgorithm, point1 : float, deriv1 : float, point2 : float, deriv2 : float) -> float

silent(...) from builtins.PyCapsule
silent(*args, **kwargs) Overloaded function. 1. silent(rosetta.core.optimization.LineMinimizationAlgorithm) -> bool 2. silent(self : rosetta.core.optimization.LineMinimizationAlgorithm, s_in : bool) -> NoneType

store_current_derivatives(...) from builtins.PyCapsule
store_current_derivatives(self : rosetta.core.optimization.LineMinimizationAlgorithm, curr_derivs : rosetta.utility.vector1_double) -> NoneType

class func_1d(builtins.object)

    Methods defined here:

__call__(...) from builtins.PyCapsule
__call__(self : rosetta.core.optimization.func_1d, displacement : float) -> float

__init__(...) from builtins.PyCapsule
__init__(self : rosetta.core.optimization.func_1d, start : rosetta.utility.vector1_double, dir : rosetta.utility.vector1_double, score_fxn : rosetta.core.optimization.Multifunc) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

dfunc(...) from builtins.PyCapsule
dfunc(self : rosetta.core.optimization.func_1d, displacement : float) -> float

dump(...) from builtins.PyCapsule
dump(self : rosetta.core.optimization.func_1d, displacement : float) -> NoneType Error condition wherein the computed gradient does not match the actual gradient; invokes the Multifunc::dump( vars, vars2 ) method.

get_deriv_count(...) from builtins.PyCapsule
get_deriv_count(rosetta.core.optimization.func_1d) -> int

get_eval_count(...) from builtins.PyCapsule
get_eval_count(rosetta.core.optimization.func_1d) -> int

reset_eval_count(...) from builtins.PyCapsule
reset_eval_count(rosetta.core.optimization.func_1d) -> NoneType

class lbfgs_iteration_data(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(rosetta.core.optimization.lbfgs_iteration_data) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

Data descriptors defined here:

alpha

s

y

ys

Functions

atom_tree_dfunc(...) method of builtins.PyCapsule instance
atom_tree_dfunc(pose : rosetta.core.pose.Pose, min_map : rosetta.core.optimization.MinimizerMap, scorefxn : rosetta.core.scoring.ScoreFunction, vars : rosetta.utility.vector1_double, dE_dvars : rosetta.utility.vector1_double) -> NoneType

atom_tree_get_atompairE_deriv(...) method of builtins.PyCapsule instance
atom_tree_get_atompairE_deriv(pose : rosetta.core.pose.Pose, min_map : rosetta.core.optimization.MinimizerMap, scorefxn : rosetta.core.scoring.ScoreFunction) -> NoneType

cart_numerical_derivative_check(...) method of builtins.PyCapsule instance
cart_numerical_derivative_check(min_map : rosetta.core.optimization.CartesianMinimizerMap, func : rosetta.core.optimization.CartesianMultifunc, start_vars : rosetta.utility.vector1_double, dE_dvars : rosetta.utility.vector1_double, deriv_check_result : rosetta.core.optimization.NumericalDerivCheckResult, verbose : bool) -> NoneType

cartesian_collect_atompairE_deriv(...) method of builtins.PyCapsule instance
cartesian_collect_atompairE_deriv(pose : rosetta.core.pose.Pose, min_map : rosetta.core.optimization.CartesianMinimizerMap, scorefxn : rosetta.core.scoring.ScoreFunction, dE_dvars : rosetta.utility.vector1_double, scale : float) -> NoneType

cartesian_collect_torsional_deriv(...) method of builtins.PyCapsule instance
cartesian_collect_torsional_deriv(pose : rosetta.core.pose.Pose, min_map : rosetta.core.optimization.CartesianMinimizerMap, scorefxn : rosetta.core.scoring.ScoreFunction, dE_dvars : rosetta.utility.vector1_double, scale : float) -> NoneType

cartesian_dfunc(...) method of builtins.PyCapsule instance
cartesian_dfunc(pose : rosetta.core.pose.Pose, min_map : rosetta.core.optimization.CartesianMinimizerMap, scorefxn : rosetta.core.scoring.ScoreFunction, vars : rosetta.utility.vector1_double, dE_dvars : rosetta.utility.vector1_double) -> NoneType

numerical_derivative_check(...) method of builtins.PyCapsule instance
numerical_derivative_check(min_map : rosetta.core.optimization.MinimizerMap, func : rosetta.core.optimization.Multifunc, start_vars : rosetta.utility.vector1_double, dE_dvars : rosetta.utility.vector1_double, deriv_check_result : rosetta.core.optimization.NumericalDerivCheckResult, verbose : bool) -> NoneType

simple_numeric_deriv_check(...) method of builtins.PyCapsule instance
simple_numeric_deriv_check(*args, **kwargs) Overloaded function. 1. simple_numeric_deriv_check(func : rosetta.core.optimization.Multifunc, start_vars : rosetta.utility.vector1_double, dE_dvars : rosetta.utility.vector1_double, send_to_stdout : bool, verbose : bool) -> rosetta.core.optimization.SimpleDerivCheckResult Numeric deriv check for Multifuncs other than the AtomTreeMultifunc. 2. simple_numeric_deriv_check(func : rosetta.core.optimization.Multifunc, start_vars : rosetta.utility.vector1_double, dE_dvars : rosetta.utility.vector1_double, send_to_stdout : bool, verbose : bool, nsteps : int) -> rosetta.core.optimization.SimpleDerivCheckResult Numeric deriv check for Multifuncs other than the AtomTreeMultifunc.

torsional_derivative_from_cartesian_derivatives(...) method of builtins.PyCapsule instance
torsional_derivative_from_cartesian_derivatives(atom : rosetta.core.kinematics.tree.Atom, dof_node : rosetta.core.optimization.DOF_Node, dof_deriv : float, torsion_scale_factor : float) -> float