optimization

Bindings for core::optimization namespace

class pyrosetta.rosetta.core.optimization.ArmijoLineMinimization

Bases: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm

Armijo(self: pyrosetta.rosetta.core.optimization.ArmijoLineMinimization, init_step: float, func_eval: pyrosetta.rosetta.core.optimization.func_1d) float

C++: core::optimization::ArmijoLineMinimization::Armijo(double, class core::optimization::func_1d &) –> double

property _deriv_sum
property _func_to_beat
property _last_accepted_step
property _num_calls
property _num_linemin_calls
property _stored_derivatives
cubic_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::cubic_interpolation(double, double, double, double, double, double) –> double

fetch_stored_derivatives(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, get_derivs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::LineMinimizationAlgorithm::fetch_stored_derivatives(class utility::vector1<double, class std::allocator<double> > &) –> void

property max_step_limit_
nonmonotone(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm) bool

C++: core::optimization::LineMinimizationAlgorithm::nonmonotone() –> bool

provide_stored_derivatives(self: pyrosetta.rosetta.core.optimization.ArmijoLineMinimization) bool

C++: core::optimization::ArmijoLineMinimization::provide_stored_derivatives() –> bool

quadratic_deriv_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::quadratic_deriv_interpolation(double, double, double, double, double, double) –> double

quadratic_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float) float

C++: core::optimization::LineMinimizationAlgorithm::quadratic_interpolation(double, double, double, double, double) –> double

secant_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, deriv1: float, point2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::secant_interpolation(double, double, double, double) –> double

silent(*args, **kwargs)

Overloaded function.

  1. silent(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm) -> bool

C++: core::optimization::LineMinimizationAlgorithm::silent() –> bool

  1. silent(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, s_in: bool) -> None

C++: core::optimization::LineMinimizationAlgorithm::silent(bool) –> void

store_current_derivatives(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, curr_derivs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::LineMinimizationAlgorithm::store_current_derivatives(class utility::vector1<double, class std::allocator<double> > &) –> void

class pyrosetta.rosetta.core.optimization.AtomTreeMinimizer

Bases: pybind11_builtins.pybind11_object

High-level atom tree minimizer class

assign(self: pyrosetta.rosetta.core.optimization.AtomTreeMinimizer, : pyrosetta.rosetta.core.optimization.AtomTreeMinimizer) pyrosetta.rosetta.core.optimization.AtomTreeMinimizer

C++: core::optimization::AtomTreeMinimizer::operator=(const class core::optimization::AtomTreeMinimizer &) –> class core::optimization::AtomTreeMinimizer &

check_setup(self: pyrosetta.rosetta.core.optimization.AtomTreeMinimizer, pose: pyrosetta.rosetta.core.pose.Pose, move_map: pyrosetta.rosetta.core.kinematics.MoveMap, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, options: core::optimization::MinimizerOptions) None

Do consistency checks for minimizer setup.

C++: core::optimization::AtomTreeMinimizer::check_setup(const class core::pose::Pose &, const class core::kinematics::MoveMap &, const class core::scoring::ScoreFunction &, const class core::optimization::MinimizerOptions &) const –> void

deriv_check_result(self: pyrosetta.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;

C++: core::optimization::AtomTreeMinimizer::deriv_check_result() const –> class std::shared_ptr<class core::optimization::NumericalDerivCheckResult>

run(self: pyrosetta.rosetta.core.optimization.AtomTreeMinimizer, pose: pyrosetta.rosetta.core.pose.Pose, move_map: pyrosetta.rosetta.core.kinematics.MoveMap, scorefxn: pyrosetta.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.

C++: core::optimization::AtomTreeMinimizer::run(class core::pose::Pose &, const class core::kinematics::MoveMap &, const class core::scoring::ScoreFunction &, const class core::optimization::MinimizerOptions &) –> double

class pyrosetta.rosetta.core.optimization.AtomTreeMultifunc

Bases: pyrosetta.rosetta.core.optimization.Multifunc

Atom tree multifunction class

abort_min(self: pyrosetta.rosetta.core.optimization.Multifunc, : pyrosetta.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!

C++: core::optimization::Multifunc::abort_min(const class utility::vector1<double, class std::allocator<double> > &) const –> bool

dfunc(self: pyrosetta.rosetta.core.optimization.AtomTreeMultifunc, vars: pyrosetta.rosetta.utility.vector1_double, dE_dvars: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::AtomTreeMultifunc::dfunc(const class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) const –> void

dump(self: pyrosetta.rosetta.core.optimization.AtomTreeMultifunc, vars: pyrosetta.rosetta.utility.vector1_double, vars2: pyrosetta.rosetta.utility.vector1_double) None

Error state reached – derivative does not match gradient

C++: core::optimization::AtomTreeMultifunc::dump(const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &) const –> void

set_deriv_check_result(self: pyrosetta.rosetta.core.optimization.AtomTreeMultifunc, deriv_check_result: core::optimization::NumericalDerivCheckResult) None

C++: core::optimization::AtomTreeMultifunc::set_deriv_check_result(class std::shared_ptr<class core::optimization::NumericalDerivCheckResult>) –> void

class pyrosetta.rosetta.core.optimization.BrentLineMinimization

Bases: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm

BRENT(self: pyrosetta.rosetta.core.optimization.BrentLineMinimization, AX: float, BX: float, CX: float, FA: float, FB: float, FC: float, TOL: float, func_eval: pyrosetta.rosetta.core.optimization.func_1d) float

C++: core::optimization::BrentLineMinimization::BRENT(const double, const double, const double, double &, double &, const double, const double, class core::optimization::func_1d &) –> double

MNBRAK(self: pyrosetta.rosetta.core.optimization.BrentLineMinimization, AX: float, BX: float, CX: float, FA: float, FB: float, FC: float, func_eval: pyrosetta.rosetta.core.optimization.func_1d) None

C++: core::optimization::BrentLineMinimization::MNBRAK(double &, double &, double &, double &, double &, double &, class core::optimization::func_1d &) const –> void

property _abs_tolerance
property _ax
property _bx
property _deriv_sum
property _func_to_beat
property _last_accepted_step
property _num_linemin_calls
property _stored_derivatives
property _xx
cubic_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::cubic_interpolation(double, double, double, double, double, double) –> double

property deriv_cutoff_
fetch_stored_derivatives(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, get_derivs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::LineMinimizationAlgorithm::fetch_stored_derivatives(class utility::vector1<double, class std::allocator<double> > &) –> void

nonmonotone(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm) bool

C++: core::optimization::LineMinimizationAlgorithm::nonmonotone() –> bool

provide_stored_derivatives(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm) bool

C++: core::optimization::LineMinimizationAlgorithm::provide_stored_derivatives() –> bool

quadratic_deriv_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::quadratic_deriv_interpolation(double, double, double, double, double, double) –> double

quadratic_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float) float

C++: core::optimization::LineMinimizationAlgorithm::quadratic_interpolation(double, double, double, double, double) –> double

secant_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, deriv1: float, point2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::secant_interpolation(double, double, double, double) –> double

set_deriv_cutoff(self: pyrosetta.rosetta.core.optimization.BrentLineMinimization, val: float) None

C++: core::optimization::BrentLineMinimization::set_deriv_cutoff(const double &) –> void

silent(*args, **kwargs)

Overloaded function.

  1. silent(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm) -> bool

C++: core::optimization::LineMinimizationAlgorithm::silent() –> bool

  1. silent(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, s_in: bool) -> None

C++: core::optimization::LineMinimizationAlgorithm::silent(bool) –> void

store_current_derivatives(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, curr_derivs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::LineMinimizationAlgorithm::store_current_derivatives(class utility::vector1<double, class std::allocator<double> > &) –> void

class pyrosetta.rosetta.core.optimization.CMAES_Minimizer

Bases: pybind11_builtins.pybind11_object

lambda(self: pyrosetta.rosetta.core.optimization.CMAES_Minimizer, lambda_in: int) None

C++: core::optimization::CMAES_Minimizer::lambda(int) –> void

rgsigma(self: pyrosetta.rosetta.core.optimization.CMAES_Minimizer, rgsigma_in: float) None

C++: core::optimization::CMAES_Minimizer::rgsigma(double) –> void

run(self: pyrosetta.rosetta.core.optimization.CMAES_Minimizer, phipsi_inout: pyrosetta.rosetta.utility.vector1_double) float

run full blackbox CMAES minimization and return final score.

C++: core::optimization::CMAES_Minimizer::run(class utility::vector1<double, class std::allocator<double> > &) –> double

class pyrosetta.rosetta.core.optimization.CartesianMinimizer

Bases: pybind11_builtins.pybind11_object

High-level atom tree minimizer class

assign(self: pyrosetta.rosetta.core.optimization.CartesianMinimizer, : pyrosetta.rosetta.core.optimization.CartesianMinimizer) pyrosetta.rosetta.core.optimization.CartesianMinimizer

C++: core::optimization::CartesianMinimizer::operator=(const class core::optimization::CartesianMinimizer &) –> class core::optimization::CartesianMinimizer &

deriv_check_result(self: pyrosetta.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;

C++: core::optimization::CartesianMinimizer::deriv_check_result() const –> class std::shared_ptr<class core::optimization::NumericalDerivCheckResult>

run(self: pyrosetta.rosetta.core.optimization.CartesianMinimizer, pose: pyrosetta.rosetta.core.pose.Pose, move_map: pyrosetta.rosetta.core.kinematics.MoveMap, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, options: pyrosetta.rosetta.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.

C++: core::optimization::CartesianMinimizer::run(class core::pose::Pose &, const class core::kinematics::MoveMap &, const class core::scoring::ScoreFunction &, const class core::optimization::MinimizerOptions &) –> double

class pyrosetta.rosetta.core.optimization.CartesianMinimizerMap

Bases: pyrosetta.rosetta.core.kinematics.MinimizerMapBase

add_atom(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, AtomID: pyrosetta.rosetta.core.id.AtomID, dof_id: pyrosetta.rosetta.core.id.DOF_ID) None

C++: core::optimization::CartesianMinimizerMap::add_atom(const class core::id::AtomID &, const class core::id::DOF_ID &) –> void

add_torsion(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, new_torsion: pyrosetta.rosetta.core.id.DOF_ID, parent: pyrosetta.rosetta.core.id.DOF_ID) None

C++: core::optimization::CartesianMinimizerMap::add_torsion(const class core::id::DOF_ID &, const class core::id::DOF_ID &) –> void

assign(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, : pyrosetta.rosetta.core.optimization.CartesianMinimizerMap) pyrosetta.rosetta.core.optimization.CartesianMinimizerMap

C++: core::optimization::CartesianMinimizerMap::operator=(const class core::optimization::CartesianMinimizerMap &) –> class core::optimization::CartesianMinimizerMap &

atom_derivatives(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, resid: int) pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair

C++: core::optimization::CartesianMinimizerMap::atom_derivatives(unsigned long) –> class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &

atom_is_moving(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, x: pyrosetta.rosetta.core.id.AtomID) bool

C++: core::optimization::CartesianMinimizerMap::atom_is_moving(class core::id::AtomID) const –> bool

copy_dofs_from_pose(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, pose: pyrosetta.rosetta.core.pose.Pose, dofs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::CartesianMinimizerMap::copy_dofs_from_pose(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &) const –> void

copy_dofs_to_pose(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, pose: pyrosetta.rosetta.core.pose.Pose, dofs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::CartesianMinimizerMap::copy_dofs_to_pose(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &) const –> void

domain_map(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap) pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t

C++: core::optimization::CartesianMinimizerMap::domain_map() const –> const class ObjexxFCL::FArray1D<int> &

get_TorsionID(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, n: int) pyrosetta.rosetta.core.id.TorsionID

C++: core::optimization::CartesianMinimizerMap::get_TorsionID(unsigned long) const –> class core::id::TorsionID

get_atom(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, n: int) pyrosetta.rosetta.core.id.AtomID

C++: core::optimization::CartesianMinimizerMap::get_atom(unsigned long) const –> class core::id::AtomID

get_atom_index(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, x: pyrosetta.rosetta.core.id.AtomID) int

C++: core::optimization::CartesianMinimizerMap::get_atom_index(class core::id::AtomID) const –> unsigned long

get_dof_id(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, n: int) pyrosetta.rosetta.core.id.DOF_ID

C++: core::optimization::CartesianMinimizerMap::get_dof_id(unsigned long) const –> class core::id::DOF_ID

natoms(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap) int

C++: core::optimization::CartesianMinimizerMap::natoms() const –> int

ndofs(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap) int

C++: core::optimization::CartesianMinimizerMap::ndofs() const –> int

ntorsions(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap) int

C++: core::optimization::CartesianMinimizerMap::ntorsions() const –> int

reset(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, pose: pyrosetta.rosetta.core.pose.Pose) None

clears old data+dimensions dof_node_pointer using size data from the pose

C++: core::optimization::CartesianMinimizerMap::reset(const class core::pose::Pose &) –> void

setup(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, pose: pyrosetta.rosetta.core.pose.Pose, move_map: pyrosetta.rosetta.core.kinematics.MoveMap) None

C++: core::optimization::CartesianMinimizerMap::setup(class core::pose::Pose &, const class core::kinematics::MoveMap &) –> void

zero_stored_derivs(self: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap) None

C++: core::optimization::CartesianMinimizerMap::zero_stored_derivs() –> void

class pyrosetta.rosetta.core.optimization.CartesianMultifunc

Bases: pyrosetta.rosetta.core.optimization.Multifunc

Atom tree multifunction class

abort_min(self: pyrosetta.rosetta.core.optimization.Multifunc, : pyrosetta.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!

C++: core::optimization::Multifunc::abort_min(const class utility::vector1<double, class std::allocator<double> > &) const –> bool

dfunc(self: pyrosetta.rosetta.core.optimization.CartesianMultifunc, vars: pyrosetta.rosetta.utility.vector1_double, dE_dvars: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::CartesianMultifunc::dfunc(const class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) const –> void

dump(self: pyrosetta.rosetta.core.optimization.CartesianMultifunc, vars: pyrosetta.rosetta.utility.vector1_double, vars2: pyrosetta.rosetta.utility.vector1_double) None

Error state reached – derivative does not match gradient

C++: core::optimization::CartesianMultifunc::dump(const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &) const –> void

set_deriv_check_result(self: pyrosetta.rosetta.core.optimization.CartesianMultifunc, deriv_check_result: core::optimization::NumericalDerivCheckResult) None

C++: core::optimization::CartesianMultifunc::set_deriv_check_result(class std::shared_ptr<class core::optimization::NumericalDerivCheckResult>) –> void

class pyrosetta.rosetta.core.optimization.ConvergenceTest

Bases: pybind11_builtins.pybind11_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.

assign(self: pyrosetta.rosetta.core.optimization.ConvergenceTest, : pyrosetta.rosetta.core.optimization.ConvergenceTest) pyrosetta.rosetta.core.optimization.ConvergenceTest

C++: core::optimization::ConvergenceTest::operator=(const class core::optimization::ConvergenceTest &) –> class core::optimization::ConvergenceTest &

class pyrosetta.rosetta.core.optimization.DFPMinConvergedAbsolute

Bases: pyrosetta.rosetta.core.optimization.ConvergenceTest

assign(self: pyrosetta.rosetta.core.optimization.DFPMinConvergedAbsolute, : pyrosetta.rosetta.core.optimization.DFPMinConvergedAbsolute) pyrosetta.rosetta.core.optimization.DFPMinConvergedAbsolute

C++: core::optimization::DFPMinConvergedAbsolute::operator=(const class core::optimization::DFPMinConvergedAbsolute &) –> class core::optimization::DFPMinConvergedAbsolute &

class pyrosetta.rosetta.core.optimization.DFPMinConvergedFractional

Bases: pyrosetta.rosetta.core.optimization.ConvergenceTest

assign(self: pyrosetta.rosetta.core.optimization.DFPMinConvergedFractional, : pyrosetta.rosetta.core.optimization.DFPMinConvergedFractional) pyrosetta.rosetta.core.optimization.DFPMinConvergedFractional

C++: core::optimization::DFPMinConvergedFractional::operator=(const class core::optimization::DFPMinConvergedFractional &) –> class core::optimization::DFPMinConvergedFractional &

class pyrosetta.rosetta.core.optimization.DOF_DataPoint

Bases: pybind11_builtins.pybind11_object

ana_deriv(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint) float

C++: core::optimization::DOF_DataPoint::ana_deriv() const –> double

assign(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint, : pyrosetta.rosetta.core.optimization.DOF_DataPoint) pyrosetta.rosetta.core.optimization.DOF_DataPoint

C++: core::optimization::DOF_DataPoint::operator=(const class core::optimization::DOF_DataPoint &) –> class core::optimization::DOF_DataPoint &

dof_id(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint) pyrosetta.rosetta.core.id.DOF_ID

C++: core::optimization::DOF_DataPoint::dof_id() const –> const class core::id::DOF_ID &

dof_val(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint) float

C++: core::optimization::DOF_DataPoint::dof_val() const –> double

f00(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint) float

C++: core::optimization::DOF_DataPoint::f00() const –> double

f11(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint) float

C++: core::optimization::DOF_DataPoint::f11() const –> double

f22(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint) float

C++: core::optimization::DOF_DataPoint::f22() const –> double

natoms(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint) int

C++: core::optimization::DOF_DataPoint::natoms() const –> unsigned long

num_deriv(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint) float

C++: core::optimization::DOF_DataPoint::num_deriv() const –> double

parent_id(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint) pyrosetta.rosetta.core.id.DOF_ID

C++: core::optimization::DOF_DataPoint::parent_id() const –> const class core::id::DOF_ID &

ratio(self: pyrosetta.rosetta.core.optimization.DOF_DataPoint) float

C++: core::optimization::DOF_DataPoint::ratio() const –> double

class pyrosetta.rosetta.core.optimization.DOF_Node

Bases: pybind11_builtins.pybind11_object

F1(self: pyrosetta.rosetta.core.optimization.DOF_Node) pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::optimization::DOF_Node::F1() –> class numeric::xyzVector<double> &

F2(self: pyrosetta.rosetta.core.optimization.DOF_Node) pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::optimization::DOF_Node::F2() –> class numeric::xyzVector<double> &

add_atom(self: pyrosetta.rosetta.core.optimization.DOF_Node, atom: pyrosetta.rosetta.core.id.AtomID) None

C++: core::optimization::DOF_Node::add_atom(const class core::id::AtomID &) –> void

assign(self: pyrosetta.rosetta.core.optimization.DOF_Node, : pyrosetta.rosetta.core.optimization.DOF_Node) pyrosetta.rosetta.core.optimization.DOF_Node

C++: core::optimization::DOF_Node::operator=(const class core::optimization::DOF_Node &) –> class core::optimization::DOF_Node &

atom_id(self: pyrosetta.rosetta.core.optimization.DOF_Node) pyrosetta.rosetta.core.id.AtomID

C++: core::optimization::DOF_Node::atom_id() const –> const class core::id::AtomID &

atomno(self: pyrosetta.rosetta.core.optimization.DOF_Node) int

C++: core::optimization::DOF_Node::atomno() const –> int

atoms(self: pyrosetta.rosetta.core.optimization.DOF_Node) pyrosetta.rosetta.utility.vector1_core_id_AtomID

C++: core::optimization::DOF_Node::atoms() const –> const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &

clear_atoms(self: pyrosetta.rosetta.core.optimization.DOF_Node) None

C++: core::optimization::DOF_Node::clear_atoms() –> void

dependent(*args, **kwargs)

Overloaded function.

  1. dependent(self: pyrosetta.rosetta.core.optimization.DOF_Node) -> bool

C++: core::optimization::DOF_Node::dependent() const –> bool

  1. dependent(self: pyrosetta.rosetta.core.optimization.DOF_Node, setting: bool) -> None

C++: core::optimization::DOF_Node::dependent(const bool) –> void

depth(self: pyrosetta.rosetta.core.optimization.DOF_Node) int

C++: core::optimization::DOF_Node::depth() const –> int

dof_id(self: pyrosetta.rosetta.core.optimization.DOF_Node) pyrosetta.rosetta.core.id.DOF_ID

C++: core::optimization::DOF_Node::dof_id() const –> const class core::id::DOF_ID &

sum derivative contributions down the tree

C++: core::optimization::DOF_Node::link_vectors() –> void

parent(self: pyrosetta.rosetta.core.optimization.DOF_Node) pyrosetta.rosetta.core.optimization.DOF_Node

C++: core::optimization::DOF_Node::parent() const –> class std::shared_ptr<const class core::optimization::DOF_Node>

rsd(self: pyrosetta.rosetta.core.optimization.DOF_Node) int

C++: core::optimization::DOF_Node::rsd() const –> int

set_id(self: pyrosetta.rosetta.core.optimization.DOF_Node, setting: pyrosetta.rosetta.core.id.DOF_ID) None

C++: core::optimization::DOF_Node::set_id(const class core::id::DOF_ID &) –> void

set_parent(self: pyrosetta.rosetta.core.optimization.DOF_Node, setting: pyrosetta.rosetta.core.optimization.DOF_Node) None

C++: core::optimization::DOF_Node::set_parent(class std::shared_ptr<class core::optimization::DOF_Node>) –> void

to_string(self: pyrosetta.rosetta.core.optimization.DOF_Node) str

C++: core::optimization::DOF_Node::to_string() const –> std::string

torsion_id(*args, **kwargs)

Overloaded function.

  1. torsion_id(self: pyrosetta.rosetta.core.optimization.DOF_Node) -> pyrosetta.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

C++: core::optimization::DOF_Node::torsion_id() const –> const class core::id::TorsionID &

  1. torsion_id(self: pyrosetta.rosetta.core.optimization.DOF_Node, id_in: pyrosetta.rosetta.core.id.TorsionID) -> None

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

C++: core::optimization::DOF_Node::torsion_id(const class core::id::TorsionID &) –> void

type(self: pyrosetta.rosetta.core.optimization.DOF_Node) pyrosetta.rosetta.core.id.DOF_Type

C++: core::optimization::DOF_Node::type() const –> enum core::id::DOF_Type

class pyrosetta.rosetta.core.optimization.DerivCheckDataPoint

Bases: pybind11_builtins.pybind11_object

ana_deriv(self: pyrosetta.rosetta.core.optimization.DerivCheckDataPoint) float

C++: core::optimization::DerivCheckDataPoint::ana_deriv() const –> double

assign(self: pyrosetta.rosetta.core.optimization.DerivCheckDataPoint, : pyrosetta.rosetta.core.optimization.DerivCheckDataPoint) pyrosetta.rosetta.core.optimization.DerivCheckDataPoint

C++: core::optimization::DerivCheckDataPoint::operator=(const class core::optimization::DerivCheckDataPoint &) –> class core::optimization::DerivCheckDataPoint &

dof_val(self: pyrosetta.rosetta.core.optimization.DerivCheckDataPoint) float

C++: core::optimization::DerivCheckDataPoint::dof_val() const –> double

f00(self: pyrosetta.rosetta.core.optimization.DerivCheckDataPoint) float

C++: core::optimization::DerivCheckDataPoint::f00() const –> double

f11(self: pyrosetta.rosetta.core.optimization.DerivCheckDataPoint) float

C++: core::optimization::DerivCheckDataPoint::f11() const –> double

f22(self: pyrosetta.rosetta.core.optimization.DerivCheckDataPoint) float

C++: core::optimization::DerivCheckDataPoint::f22() const –> double

num_deriv(self: pyrosetta.rosetta.core.optimization.DerivCheckDataPoint) float

C++: core::optimization::DerivCheckDataPoint::num_deriv() const –> double

ratio(self: pyrosetta.rosetta.core.optimization.DerivCheckDataPoint) float

C++: core::optimization::DerivCheckDataPoint::ratio() const –> double

class pyrosetta.rosetta.core.optimization.DescentDirectionAlgorithm

Bases: pybind11_builtins.pybind11_object

initialize(self: pyrosetta.rosetta.core.optimization.DescentDirectionAlgorithm) None

C++: core::optimization::DescentDirectionAlgorithm::initialize() –> void

class pyrosetta.rosetta.core.optimization.EItem

Bases: pybind11_builtins.pybind11_object

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

property r
static sort_R_function(e1: pyrosetta.rosetta.core.optimization.EItem, e2: pyrosetta.rosetta.core.optimization.EItem) bool

C++: core::optimization::EItem::sort_R_function(const class core::optimization::EItem &, const class core::optimization::EItem &) –> bool

property tag
property v
class pyrosetta.rosetta.core.optimization.GA_Minimizer

Bases: pybind11_builtins.pybind11_object

run(self: pyrosetta.rosetta.core.optimization.GA_Minimizer, phipsi_inout: pyrosetta.rosetta.utility.vector1_double, max_time: int) float

C++: core::optimization::GA_Minimizer::run(class utility::vector1<double, class std::allocator<double> > &, int) –> double

class pyrosetta.rosetta.core.optimization.JJH_Minimizer

Bases: pybind11_builtins.pybind11_object

run(self: pyrosetta.rosetta.core.optimization.JJH_Minimizer, angles: pyrosetta.rosetta.utility.vector1_double) float

C++: core::optimization::JJH_Minimizer::run(class utility::vector1<double, class std::allocator<double> > &) –> double

class pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm

Bases: pybind11_builtins.pybind11_object

property _deriv_sum
property _func_to_beat
property _last_accepted_step
property _num_linemin_calls
property _stored_derivatives
cubic_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::cubic_interpolation(double, double, double, double, double, double) –> double

fetch_stored_derivatives(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, get_derivs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::LineMinimizationAlgorithm::fetch_stored_derivatives(class utility::vector1<double, class std::allocator<double> > &) –> void

nonmonotone(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm) bool

C++: core::optimization::LineMinimizationAlgorithm::nonmonotone() –> bool

provide_stored_derivatives(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm) bool

C++: core::optimization::LineMinimizationAlgorithm::provide_stored_derivatives() –> bool

quadratic_deriv_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::quadratic_deriv_interpolation(double, double, double, double, double, double) –> double

quadratic_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float) float

C++: core::optimization::LineMinimizationAlgorithm::quadratic_interpolation(double, double, double, double, double) –> double

secant_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, deriv1: float, point2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::secant_interpolation(double, double, double, double) –> double

silent(*args, **kwargs)

Overloaded function.

  1. silent(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm) -> bool

C++: core::optimization::LineMinimizationAlgorithm::silent() –> bool

  1. silent(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, s_in: bool) -> None

C++: core::optimization::LineMinimizationAlgorithm::silent(bool) –> void

store_current_derivatives(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, curr_derivs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::LineMinimizationAlgorithm::store_current_derivatives(class utility::vector1<double, class std::allocator<double> > &) –> void

class pyrosetta.rosetta.core.optimization.Minimizer

Bases: pybind11_builtins.pybind11_object

Simple low-level minimizer class

run(self: pyrosetta.rosetta.core.optimization.Minimizer, phipsi_inout: pyrosetta.rosetta.utility.vector1_double) float

C++: core::optimization::Minimizer::run(class utility::vector1<double, class std::allocator<double> > &) –> double

class pyrosetta.rosetta.core.optimization.MinimizerMap

Bases: pyrosetta.rosetta.core.kinematics.MinimizerMapBase

add_atom(self: pyrosetta.rosetta.core.optimization.MinimizerMap, atom_id: pyrosetta.rosetta.core.id.AtomID, dof_id: pyrosetta.rosetta.core.id.DOF_ID) None

C++: core::optimization::MinimizerMap::add_atom(const class core::id::AtomID &, const class core::id::DOF_ID &) –> void

add_torsion(self: pyrosetta.rosetta.core.optimization.MinimizerMap, new_torsion: pyrosetta.rosetta.core.id.DOF_ID, parent: pyrosetta.rosetta.core.id.DOF_ID) None

C++: core::optimization::MinimizerMap::add_torsion(const class core::id::DOF_ID &, const class core::id::DOF_ID &) –> void

assign(self: pyrosetta.rosetta.core.optimization.MinimizerMap, : pyrosetta.rosetta.core.optimization.MinimizerMap) pyrosetta.rosetta.core.optimization.MinimizerMap

C++: core::optimization::MinimizerMap::operator=(const class core::optimization::MinimizerMap &) –> class core::optimization::MinimizerMap &

atom_derivatives(self: pyrosetta.rosetta.core.optimization.MinimizerMap, resid: int) pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair

C++: core::optimization::MinimizerMap::atom_derivatives(unsigned long) –> class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &

copy_dofs_from_pose(self: pyrosetta.rosetta.core.optimization.MinimizerMap, pose: pyrosetta.rosetta.core.pose.Pose, dofs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::MinimizerMap::copy_dofs_from_pose(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &) const –> void

copy_dofs_to_pose(self: pyrosetta.rosetta.core.optimization.MinimizerMap, pose: pyrosetta.rosetta.core.pose.Pose, dofs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::MinimizerMap::copy_dofs_to_pose(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &) const –> void

dof_node_from_id(self: pyrosetta.rosetta.core.optimization.MinimizerMap, id: pyrosetta.rosetta.core.id.DOF_ID) pyrosetta.rosetta.core.optimization.DOF_Node

get a dof_node by its dof_id

C++: core::optimization::MinimizerMap::dof_node_from_id(const class core::id::DOF_ID &) –> class std::shared_ptr<class core::optimization::DOF_Node>

dof_nodes(self: pyrosetta.rosetta.core.optimization.MinimizerMap) pyrosetta.rosetta.std.list_std_shared_ptr_core_optimization_DOF_Node_std_allocator_std_shared_ptr_core_optimization_DOF_Node_t

C++: core::optimization::MinimizerMap::dof_nodes() –> class std::list<class std::shared_ptr<class core::optimization::DOF_Node>, class std::allocator<class std::shared_ptr<class core::optimization::DOF_Node> > > &

domain_map(self: pyrosetta.rosetta.core.optimization.MinimizerMap) pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t

C++: core::optimization::MinimizerMap::domain_map() const –> const class ObjexxFCL::FArray1D<int> &

this will only work if DOF_nodes are sorted!

C++: core::optimization::MinimizerMap::link_torsion_vectors() –> void

nangles(self: pyrosetta.rosetta.core.optimization.MinimizerMap) int

C++: core::optimization::MinimizerMap::nangles() const –> int

reset(self: pyrosetta.rosetta.core.optimization.MinimizerMap, pose: pyrosetta.rosetta.core.pose.Pose) None

clears old data+dimensions dof_node_pointer using size data from the pose

C++: core::optimization::MinimizerMap::reset(const class core::pose::Pose &) –> void

reset_jump_rb_deltas(self: pyrosetta.rosetta.core.optimization.MinimizerMap, pose: pyrosetta.rosetta.core.pose.Pose, dofs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::MinimizerMap::reset_jump_rb_deltas(class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &) const –> void

setup(self: pyrosetta.rosetta.core.optimization.MinimizerMap, pose: pyrosetta.rosetta.core.pose.Pose, move_map: pyrosetta.rosetta.core.kinematics.MoveMap) None

C++: core::optimization::MinimizerMap::setup(class core::pose::Pose &, const class core::kinematics::MoveMap &) –> void

torsion_scale_factor(self: pyrosetta.rosetta.core.optimization.MinimizerMap, tor: pyrosetta.rosetta.core.optimization.DOF_Node) float

C++: core::optimization::MinimizerMap::torsion_scale_factor(const class core::optimization::DOF_Node &) const –> double

zero_torsion_vectors(self: pyrosetta.rosetta.core.optimization.MinimizerMap) None

C++: core::optimization::MinimizerMap::zero_torsion_vectors() –> void

class pyrosetta.rosetta.core.optimization.MinimizerOptions

Bases: pybind11_builtins.pybind11_object

armijo_max_step_limit(*args, **kwargs)

Overloaded function.

  1. armijo_max_step_limit(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> float

C++: core::optimization::MinimizerOptions::armijo_max_step_limit() const –> double

  1. armijo_max_step_limit(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, lim: float) -> None

C++: core::optimization::MinimizerOptions::armijo_max_step_limit(double) –> void

assign(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, : pyrosetta.rosetta.core.optimization.MinimizerOptions) pyrosetta.rosetta.core.optimization.MinimizerOptions

C++: core::optimization::MinimizerOptions::operator=(const class core::optimization::MinimizerOptions &) –> class core::optimization::MinimizerOptions &

ax_init(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) float

C++: core::optimization::MinimizerOptions::ax_init() const –> double

brent_abs_tolerance(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) float

C++: core::optimization::MinimizerOptions::brent_abs_tolerance() const –> double

bx_init(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) float

C++: core::optimization::MinimizerOptions::bx_init() const –> double

clone(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) pyrosetta.rosetta.core.optimization.MinimizerOptions

C++: core::optimization::MinimizerOptions::clone() const –> class std::shared_ptr<class core::optimization::MinimizerOptions>

cmaes_lambda(*args, **kwargs)

Overloaded function.

  1. cmaes_lambda(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> int

C++: core::optimization::MinimizerOptions::cmaes_lambda() const –> int

  1. cmaes_lambda(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, n: int) -> None

C++: core::optimization::MinimizerOptions::cmaes_lambda(int) –> void

cmaes_rgsigma(*args, **kwargs)

Overloaded function.

  1. cmaes_rgsigma(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> float

C++: core::optimization::MinimizerOptions::cmaes_rgsigma() const –> double

  1. cmaes_rgsigma(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, s: float) -> None

C++: core::optimization::MinimizerOptions::cmaes_rgsigma(double) –> void

deriv_check(*args, **kwargs)

Overloaded function.

  1. deriv_check(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, deriv_check_in: bool) -> None

C++: core::optimization::MinimizerOptions::deriv_check(bool) –> void

  1. deriv_check(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> bool

C++: core::optimization::MinimizerOptions::deriv_check() const –> bool

deriv_check_to_stdout(*args, **kwargs)

Overloaded function.

  1. deriv_check_to_stdout(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, setting: bool) -> None

C++: core::optimization::MinimizerOptions::deriv_check_to_stdout(bool) –> void

  1. deriv_check_to_stdout(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> bool

C++: core::optimization::MinimizerOptions::deriv_check_to_stdout() const –> bool

deriv_check_verbose(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) bool

C++: core::optimization::MinimizerOptions::deriv_check_verbose() const –> bool

ga_mutation_probability(*args, **kwargs)

Overloaded function.

  1. ga_mutation_probability(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> float

C++: core::optimization::MinimizerOptions::ga_mutation_probability() const –> double

  1. ga_mutation_probability(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, p: float) -> None

C++: core::optimization::MinimizerOptions::ga_mutation_probability(double) –> void

gmax_cutoff_for_convergence(*args, **kwargs)

Overloaded function.

  1. gmax_cutoff_for_convergence(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> float

C++: core::optimization::MinimizerOptions::gmax_cutoff_for_convergence() const –> double

  1. gmax_cutoff_for_convergence(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, gmax_in: float) -> None

C++: core::optimization::MinimizerOptions::gmax_cutoff_for_convergence(double) –> void

linmin_deriv_cutoff(*args, **kwargs)

Overloaded function.

  1. linmin_deriv_cutoff(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> float

The derivative cutoff used for Brent.

C++: core::optimization::MinimizerOptions::linmin_deriv_cutoff() const –> double

  1. linmin_deriv_cutoff(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, val: float) -> None

Set the derivative cutoff used for Brent.

C++: core::optimization::MinimizerOptions::linmin_deriv_cutoff(const double &) –> void

max_iter(*args, **kwargs)

Overloaded function.

  1. max_iter(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> int

C++: core::optimization::MinimizerOptions::max_iter() const –> int

  1. max_iter(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, n: int) -> None

C++: core::optimization::MinimizerOptions::max_iter(int) –> void

min_type(*args, **kwargs)

Overloaded function.

  1. min_type(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, min_type_in: str) -> None

C++: core::optimization::MinimizerOptions::min_type(std::string) –> void

  1. min_type(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> str

C++: core::optimization::MinimizerOptions::min_type() –> std::string &

minimize_tolerance(*args, **kwargs)

Overloaded function.

  1. minimize_tolerance(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> float

C++: core::optimization::MinimizerOptions::minimize_tolerance() –> double &

  1. minimize_tolerance(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, minimize_tolerance_in: float) -> None

C++: core::optimization::MinimizerOptions::minimize_tolerance(double) –> void

nblist_auto_update(*args, **kwargs)

Overloaded function.

  1. nblist_auto_update(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> bool

C++: core::optimization::MinimizerOptions::nblist_auto_update() const –> bool

  1. nblist_auto_update(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, setting: bool) -> None

C++: core::optimization::MinimizerOptions::nblist_auto_update(bool) –> void

silent(*args, **kwargs)

Overloaded function.

  1. silent(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> bool

C++: core::optimization::MinimizerOptions::silent() const –> bool

  1. silent(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, silent_in: bool) -> None

C++: core::optimization::MinimizerOptions::silent(bool) –> void

use_nblist(*args, **kwargs)

Overloaded function.

  1. use_nblist(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> bool

Indicate whether or not a handful of optimizations regarding the
neighbor list have been enabled.

use_nblist()

C++: core::optimization::MinimizerOptions::use_nblist() const –> bool

  1. use_nblist(self: pyrosetta.rosetta.core.optimization.MinimizerOptions, use_nblist_in: bool) -> None

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

C++: core::optimization::MinimizerOptions::use_nblist(bool) –> void

xx_init(self: pyrosetta.rosetta.core.optimization.MinimizerOptions) float

C++: core::optimization::MinimizerOptions::xx_init() const –> double

class pyrosetta.rosetta.core.optimization.Multifunc

Bases: pybind11_builtins.pybind11_object

Multifunction interface class

abort_min(self: pyrosetta.rosetta.core.optimization.Multifunc, : pyrosetta.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!

C++: core::optimization::Multifunc::abort_min(const class utility::vector1<double, class std::allocator<double> > &) const –> bool

dfunc(self: pyrosetta.rosetta.core.optimization.Multifunc, phipsi: pyrosetta.rosetta.utility.vector1_double, dE_dphipsi: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::Multifunc::dfunc(const class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) const –> void

dump(self: pyrosetta.rosetta.core.optimization.Multifunc, : pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double) None
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.

C++: core::optimization::Multifunc::dump(const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &) const –> void

class pyrosetta.rosetta.core.optimization.NelderMeadSimplex

Bases: pybind11_builtins.pybind11_object

property options_
run(self: pyrosetta.rosetta.core.optimization.NelderMeadSimplex, phipsi_inout: pyrosetta.rosetta.utility.vector1_double, upperbound: pyrosetta.rosetta.utility.vector1_double) float

C++: core::optimization::NelderMeadSimplex::run(class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &) –> double

class pyrosetta.rosetta.core.optimization.NumDerivCheckData

Bases: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult

abs_deriv_dev(*args, **kwargs)

Overloaded function.

  1. abs_deriv_dev(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::abs_deriv_dev(unsigned long, double) –> void

  1. abs_deriv_dev(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int) -> float

C++: core::optimization::SimpleDerivCheckResult::abs_deriv_dev(unsigned long) const –> double

assign(self: pyrosetta.rosetta.core.optimization.NumDerivCheckData, : pyrosetta.rosetta.core.optimization.NumDerivCheckData) pyrosetta.rosetta.core.optimization.NumDerivCheckData

C++: core::optimization::NumDerivCheckData::operator=(const class core::optimization::NumDerivCheckData &) –> class core::optimization::NumDerivCheckData &

best_abs_log_norm_ratio(*args, **kwargs)

Overloaded function.

  1. best_abs_log_norm_ratio(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::best_abs_log_norm_ratio(double) –> void

  1. best_abs_log_norm_ratio(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) -> float

C++: core::optimization::SimpleDerivCheckResult::best_abs_log_norm_ratio() const –> double

best_cos_theta(*args, **kwargs)

Overloaded function.

  1. best_cos_theta(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::best_cos_theta(double) –> void

  1. best_cos_theta(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) -> float

C++: core::optimization::SimpleDerivCheckResult::best_cos_theta() const –> double

best_norm_analytic(*args, **kwargs)

Overloaded function.

  1. best_norm_analytic(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::best_norm_analytic(double) –> void

  1. best_norm_analytic(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) -> float

C++: core::optimization::SimpleDerivCheckResult::best_norm_analytic() const –> double

best_norm_numeric(*args, **kwargs)

Overloaded function.

  1. best_norm_numeric(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::best_norm_numeric(double) –> void

  1. best_norm_numeric(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) -> float

C++: core::optimization::SimpleDerivCheckResult::best_norm_numeric() const –> double

dof_step_data(*args, **kwargs)

Overloaded function.

  1. dof_step_data(self: pyrosetta.rosetta.core.optimization.NumDerivCheckData, dof_ind: int, step_ind: int, dofdp: pyrosetta.rosetta.core.optimization.DOF_DataPoint) -> None

C++: core::optimization::NumDerivCheckData::dof_step_data(unsigned long, unsigned long, const class core::optimization::DOF_DataPoint &) –> void

  1. dof_step_data(self: pyrosetta.rosetta.core.optimization.NumDerivCheckData, dof_ind: int, step_ind: int) -> pyrosetta.rosetta.core.optimization.DOF_DataPoint

C++: core::optimization::NumDerivCheckData::dof_step_data(unsigned long, unsigned long) const –> const class core::optimization::DOF_DataPoint &

nangles(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) int

C++: core::optimization::SimpleDerivCheckResult::nangles() const –> unsigned long

nsteps(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) int

C++: core::optimization::SimpleDerivCheckResult::nsteps() const –> unsigned long

rel_deriv_dev(*args, **kwargs)

Overloaded function.

  1. rel_deriv_dev(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::rel_deriv_dev(unsigned long, double) –> void

  1. rel_deriv_dev(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int) -> float

C++: core::optimization::SimpleDerivCheckResult::rel_deriv_dev(unsigned long) const –> double

step_data(*args, **kwargs)

Overloaded function.

  1. step_data(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int, step_ind: int, dp: pyrosetta.rosetta.core.optimization.DerivCheckDataPoint) -> None

C++: core::optimization::SimpleDerivCheckResult::step_data(unsigned long, unsigned long, const class core::optimization::DerivCheckDataPoint &) –> void

  1. step_data(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int, step_ind: int) -> pyrosetta.rosetta.core.optimization.DerivCheckDataPoint

C++: core::optimization::SimpleDerivCheckResult::step_data(unsigned long, unsigned long) const –> const class core::optimization::DerivCheckDataPoint &

class pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult

Bases: pybind11_builtins.pybind11_object

add_deriv_data(self: pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult, deriv_check_data: pyrosetta.rosetta.core.optimization.NumDerivCheckData) None

C++: core::optimization::NumericalDerivCheckResult::add_deriv_data(class std::shared_ptr<class core::optimization::NumDerivCheckData>) –> void

assign(self: pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult, : pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult) pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult

C++: core::optimization::NumericalDerivCheckResult::operator=(const class core::optimization::NumericalDerivCheckResult &) –> class core::optimization::NumericalDerivCheckResult &

deriv_check_result(self: pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult, ind: int) pyrosetta.rosetta.core.optimization.NumDerivCheckData

C++: core::optimization::NumericalDerivCheckResult::deriv_check_result(unsigned long) const –> const class core::optimization::NumDerivCheckData &

n_deriv_check_results(self: pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult) int

C++: core::optimization::NumericalDerivCheckResult::n_deriv_check_results() const –> unsigned long

send_to_stdout(*args, **kwargs)

Overloaded function.

  1. send_to_stdout(self: pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult, setting: bool) -> None

C++: core::optimization::NumericalDerivCheckResult::send_to_stdout(bool) –> void

  1. send_to_stdout(self: pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult) -> bool

C++: core::optimization::NumericalDerivCheckResult::send_to_stdout() const –> bool

class pyrosetta.rosetta.core.optimization.Particle

Bases: pybind11_builtins.pybind11_object

Simple data container for PSO algorithm.

assign(self: pyrosetta.rosetta.core.optimization.Particle, : pyrosetta.rosetta.core.optimization.Particle) pyrosetta.rosetta.core.optimization.Particle

C++: core::optimization::Particle::operator=(const class core::optimization::Particle &) –> class core::optimization::Particle &

ensure_size(self: pyrosetta.rosetta.core.optimization.Particle, minsize: int) None

Make sure that all arrays are large enough – prevents index-out-of-bound errors.

C++: core::optimization::Particle::ensure_size(unsigned long) –> void

property fitness_
fitness_pbest(self: pyrosetta.rosetta.core.optimization.Particle) float

C++: core::optimization::Particle::fitness_pbest() const –> double

property p_
pbest(self: pyrosetta.rosetta.core.optimization.Particle) pyrosetta.rosetta.utility.vector1_double

This is why data should be private: you get to ensure it’s valid when you read it.

C++: core::optimization::Particle::pbest() const –> const class utility::vector1<double, class std::allocator<double> > &

score(self: pyrosetta.rosetta.core.optimization.Particle, f: pyrosetta.rosetta.core.optimization.Multifunc) float

C++: core::optimization::Particle::score(class core::optimization::Multifunc &) –> double

set_score(self: pyrosetta.rosetta.core.optimization.Particle, new_score: float) float

C++: core::optimization::Particle::set_score(double &) –> double

property v_
class pyrosetta.rosetta.core.optimization.ParticleSwarmMinimizer

Bases: pybind11_builtins.pybind11_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…

assign(self: pyrosetta.rosetta.core.optimization.ParticleSwarmMinimizer, : pyrosetta.rosetta.core.optimization.ParticleSwarmMinimizer) pyrosetta.rosetta.core.optimization.ParticleSwarmMinimizer

C++: core::optimization::ParticleSwarmMinimizer::operator=(const class core::optimization::ParticleSwarmMinimizer &) –> class core::optimization::ParticleSwarmMinimizer &

class pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult

Bases: pybind11_builtins.pybind11_object

abs_deriv_dev(*args, **kwargs)

Overloaded function.

  1. abs_deriv_dev(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::abs_deriv_dev(unsigned long, double) –> void

  1. abs_deriv_dev(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int) -> float

C++: core::optimization::SimpleDerivCheckResult::abs_deriv_dev(unsigned long) const –> double

assign(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, : pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult

C++: core::optimization::SimpleDerivCheckResult::operator=(const class core::optimization::SimpleDerivCheckResult &) –> class core::optimization::SimpleDerivCheckResult &

best_abs_log_norm_ratio(*args, **kwargs)

Overloaded function.

  1. best_abs_log_norm_ratio(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::best_abs_log_norm_ratio(double) –> void

  1. best_abs_log_norm_ratio(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) -> float

C++: core::optimization::SimpleDerivCheckResult::best_abs_log_norm_ratio() const –> double

best_cos_theta(*args, **kwargs)

Overloaded function.

  1. best_cos_theta(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::best_cos_theta(double) –> void

  1. best_cos_theta(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) -> float

C++: core::optimization::SimpleDerivCheckResult::best_cos_theta() const –> double

best_norm_analytic(*args, **kwargs)

Overloaded function.

  1. best_norm_analytic(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::best_norm_analytic(double) –> void

  1. best_norm_analytic(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) -> float

C++: core::optimization::SimpleDerivCheckResult::best_norm_analytic() const –> double

best_norm_numeric(*args, **kwargs)

Overloaded function.

  1. best_norm_numeric(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::best_norm_numeric(double) –> void

  1. best_norm_numeric(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) -> float

C++: core::optimization::SimpleDerivCheckResult::best_norm_numeric() const –> double

nangles(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) int

C++: core::optimization::SimpleDerivCheckResult::nangles() const –> unsigned long

nsteps(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult) int

C++: core::optimization::SimpleDerivCheckResult::nsteps() const –> unsigned long

rel_deriv_dev(*args, **kwargs)

Overloaded function.

  1. rel_deriv_dev(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int, val: float) -> None

C++: core::optimization::SimpleDerivCheckResult::rel_deriv_dev(unsigned long, double) –> void

  1. rel_deriv_dev(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int) -> float

C++: core::optimization::SimpleDerivCheckResult::rel_deriv_dev(unsigned long) const –> double

step_data(*args, **kwargs)

Overloaded function.

  1. step_data(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int, step_ind: int, dp: pyrosetta.rosetta.core.optimization.DerivCheckDataPoint) -> None

C++: core::optimization::SimpleDerivCheckResult::step_data(unsigned long, unsigned long, const class core::optimization::DerivCheckDataPoint &) –> void

  1. step_data(self: pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult, dof_ind: int, step_ind: int) -> pyrosetta.rosetta.core.optimization.DerivCheckDataPoint

C++: core::optimization::SimpleDerivCheckResult::step_data(unsigned long, unsigned long) const –> const class core::optimization::DerivCheckDataPoint &

class pyrosetta.rosetta.core.optimization.SingleResidueMultifunc

Bases: pyrosetta.rosetta.core.optimization.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.

abort_min(self: pyrosetta.rosetta.core.optimization.Multifunc, : pyrosetta.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!

C++: core::optimization::Multifunc::abort_min(const class utility::vector1<double, class std::allocator<double> > &) const –> bool

dfunc(self: pyrosetta.rosetta.core.optimization.AtomTreeMultifunc, vars: pyrosetta.rosetta.utility.vector1_double, dE_dvars: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::AtomTreeMultifunc::dfunc(const class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) const –> void

dump(self: pyrosetta.rosetta.core.optimization.AtomTreeMultifunc, vars: pyrosetta.rosetta.utility.vector1_double, vars2: pyrosetta.rosetta.utility.vector1_double) None

Error state reached – derivative does not match gradient

C++: core::optimization::AtomTreeMultifunc::dump(const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &) const –> void

set_deriv_check_result(self: pyrosetta.rosetta.core.optimization.AtomTreeMultifunc, deriv_check_result: core::optimization::NumericalDerivCheckResult) None

C++: core::optimization::AtomTreeMultifunc::set_deriv_check_result(class std::shared_ptr<class core::optimization::NumericalDerivCheckResult>) –> void

class pyrosetta.rosetta.core.optimization.StrongWolfeLineMinimization

Bases: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm

StrongWolfe(self: pyrosetta.rosetta.core.optimization.StrongWolfeLineMinimization, init_step: float, func_eval: pyrosetta.rosetta.core.optimization.func_1d) float

C++: core::optimization::StrongWolfeLineMinimization::StrongWolfe(double, class core::optimization::func_1d &) –> double

property _deriv_sum
property _func_to_beat
property _last_accepted_step
property _nonmonotone
property _num_calls
property _num_linemin_calls
property _stored_derivatives
cubic_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::cubic_interpolation(double, double, double, double, double, double) –> double

fetch_stored_derivatives(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, get_derivs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::LineMinimizationAlgorithm::fetch_stored_derivatives(class utility::vector1<double, class std::allocator<double> > &) –> void

nonmonotone(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm) bool

C++: core::optimization::LineMinimizationAlgorithm::nonmonotone() –> bool

provide_stored_derivatives(self: pyrosetta.rosetta.core.optimization.StrongWolfeLineMinimization) bool

C++: core::optimization::StrongWolfeLineMinimization::provide_stored_derivatives() –> bool

quadratic_deriv_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::quadratic_deriv_interpolation(double, double, double, double, double, double) –> double

quadratic_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, func1: float, deriv1: float, point2: float, func2: float) float

C++: core::optimization::LineMinimizationAlgorithm::quadratic_interpolation(double, double, double, double, double) –> double

secant_interpolation(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, point1: float, deriv1: float, point2: float, deriv2: float) float

C++: core::optimization::LineMinimizationAlgorithm::secant_interpolation(double, double, double, double) –> double

silent(*args, **kwargs)

Overloaded function.

  1. silent(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm) -> bool

C++: core::optimization::LineMinimizationAlgorithm::silent() –> bool

  1. silent(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, s_in: bool) -> None

C++: core::optimization::LineMinimizationAlgorithm::silent(bool) –> void

store_current_derivatives(self: pyrosetta.rosetta.core.optimization.LineMinimizationAlgorithm, curr_derivs: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::LineMinimizationAlgorithm::store_current_derivatives(class utility::vector1<double, class std::allocator<double> > &) –> void

zoom(self: pyrosetta.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: pyrosetta.rosetta.core.optimization.func_1d) float

C++: core::optimization::StrongWolfeLineMinimization::zoom(double, double, double, double, double, double, double, double, double &, class core::optimization::func_1d &) –> double

pyrosetta.rosetta.core.optimization.activate_dof_deriv_terms_for_cart_min(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, min_map: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap) None
Activate DOF-derivative defining terms for stationary residues

if the atoms defining the DOFs these terms depend on are moving

C++: core::optimization::activate_dof_deriv_terms_for_cart_min(class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::optimization::CartesianMinimizerMap &) –> void

pyrosetta.rosetta.core.optimization.atom_tree_dfunc(pose: pyrosetta.rosetta.core.pose.Pose, min_map: pyrosetta.rosetta.core.optimization.MinimizerMap, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, vars: pyrosetta.rosetta.utility.vector1_double, dE_dvars: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::atom_tree_dfunc(class core::pose::Pose &, class core::optimization::MinimizerMap &, const class core::scoring::ScoreFunction &, const class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

pyrosetta.rosetta.core.optimization.atom_tree_get_atompairE_deriv(pose: pyrosetta.rosetta.core.pose.Pose, min_map: pyrosetta.rosetta.core.optimization.MinimizerMap, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::optimization::atom_tree_get_atompairE_deriv(class core::pose::Pose &, class core::optimization::MinimizerMap &, const class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.optimization.cart_numerical_derivative_check(min_map: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, func: pyrosetta.rosetta.core.optimization.CartesianMultifunc, start_vars: pyrosetta.rosetta.utility.vector1_double, dE_dvars: pyrosetta.rosetta.utility.vector1_double, deriv_check_result: pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult, verbose: bool) None

C++: core::optimization::cart_numerical_derivative_check(const class core::optimization::CartesianMinimizerMap &, const class core::optimization::CartesianMultifunc &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, class std::shared_ptr<class core::optimization::NumericalDerivCheckResult>, const bool) –> void

pyrosetta.rosetta.core.optimization.cartesian_collect_atompairE_deriv(pose: pyrosetta.rosetta.core.pose.Pose, min_map: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, dE_dvars: pyrosetta.rosetta.utility.vector1_double, scale: float) None

C++: core::optimization::cartesian_collect_atompairE_deriv(class core::pose::Pose &, class core::optimization::CartesianMinimizerMap &, const class core::scoring::ScoreFunction &, class utility::vector1<double, class std::allocator<double> > &, double) –> void

pyrosetta.rosetta.core.optimization.cartesian_collect_torsional_deriv(pose: pyrosetta.rosetta.core.pose.Pose, min_map: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, dE_dvars: pyrosetta.rosetta.utility.vector1_double, scale: float) None

C++: core::optimization::cartesian_collect_torsional_deriv(class core::pose::Pose &, class core::optimization::CartesianMinimizerMap &, const class core::scoring::ScoreFunction &, class utility::vector1<double, class std::allocator<double> > &, double) –> void

pyrosetta.rosetta.core.optimization.cartesian_dfunc(pose: pyrosetta.rosetta.core.pose.Pose, min_map: pyrosetta.rosetta.core.optimization.CartesianMinimizerMap, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, vars: pyrosetta.rosetta.utility.vector1_double, dE_dvars: pyrosetta.rosetta.utility.vector1_double) None

C++: core::optimization::cartesian_dfunc(class core::pose::Pose &, class core::optimization::CartesianMinimizerMap &, const class core::scoring::ScoreFunction &, const class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

class pyrosetta.rosetta.core.optimization.func_1d

Bases: pybind11_builtins.pybind11_object

property _dE_dvars
dfunc(self: pyrosetta.rosetta.core.optimization.func_1d, displacement: float) float

C++: core::optimization::func_1d::dfunc(double) –> double

dump(self: pyrosetta.rosetta.core.optimization.func_1d, displacement: float) None
Error condition wherein the computed gradient does not match the actual gradient;

invokes the Multifunc::dump( vars, vars2 ) method.

C++: core::optimization::func_1d::dump(double) –> void

get_deriv_count(self: pyrosetta.rosetta.core.optimization.func_1d) int

C++: core::optimization::func_1d::get_deriv_count() –> int

get_eval_count(self: pyrosetta.rosetta.core.optimization.func_1d) int

C++: core::optimization::func_1d::get_eval_count() –> int

reset_eval_count(self: pyrosetta.rosetta.core.optimization.func_1d) None

C++: core::optimization::func_1d::reset_eval_count() –> void

class pyrosetta.rosetta.core.optimization.lbfgs_iteration_data

Bases: pybind11_builtins.pybind11_object

property alpha
property s
property y
property ys
pyrosetta.rosetta.core.optimization.numerical_derivative_check(min_map: pyrosetta.rosetta.core.optimization.MinimizerMap, func: pyrosetta.rosetta.core.optimization.Multifunc, start_vars: pyrosetta.rosetta.utility.vector1_double, dE_dvars: pyrosetta.rosetta.utility.vector1_double, deriv_check_result: pyrosetta.rosetta.core.optimization.NumericalDerivCheckResult, verbose: bool) None

C++: core::optimization::numerical_derivative_check(const class core::optimization::MinimizerMap &, const class core::optimization::Multifunc &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, class std::shared_ptr<class core::optimization::NumericalDerivCheckResult>, const bool) –> void

pyrosetta.rosetta.core.optimization.simple_numeric_deriv_check(*args, **kwargs)

Overloaded function.

  1. simple_numeric_deriv_check(func: pyrosetta.rosetta.core.optimization.Multifunc, start_vars: pyrosetta.rosetta.utility.vector1_double, dE_dvars: pyrosetta.rosetta.utility.vector1_double, send_to_stdout: bool, verbose: bool) -> pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult

  2. simple_numeric_deriv_check(func: pyrosetta.rosetta.core.optimization.Multifunc, start_vars: pyrosetta.rosetta.utility.vector1_double, dE_dvars: pyrosetta.rosetta.utility.vector1_double, send_to_stdout: bool, verbose: bool, nsteps: int) -> pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult

  3. simple_numeric_deriv_check(func: pyrosetta.rosetta.core.optimization.Multifunc, start_vars: pyrosetta.rosetta.utility.vector1_double, dE_dvars: pyrosetta.rosetta.utility.vector1_double, send_to_stdout: bool, verbose: bool, nsteps: int, increment: float) -> pyrosetta.rosetta.core.optimization.SimpleDerivCheckResult

Numeric deriv check for Multifuncs other than the AtomTreeMultifunc.

C++: core::optimization::simple_numeric_deriv_check(const class core::optimization::Multifunc &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, bool, bool, unsigned long, const double) –> class core::optimization::SimpleDerivCheckResult

pyrosetta.rosetta.core.optimization.torsional_derivative_from_cartesian_derivatives(atom: pyrosetta.rosetta.core.kinematics.tree.Atom, dof_node: pyrosetta.rosetta.core.optimization.DOF_Node, dof_deriv: float, torsion_scale_factor: float) float

C++: core::optimization::torsional_derivative_from_cartesian_derivatives(const class core::kinematics::tree::Atom &, const class core::optimization::DOF_Node &, double, double) –> double