optimization¶

symmetry

Bindings for core::optimization namespace

class pyrosetta.rosetta.core.optimization.ArmijoLineMinimization¶

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

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

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

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_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: 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: 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.

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

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

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_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_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: 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: 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_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: 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: 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_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_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.

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

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

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 &

link_vectors(self: pyrosetta.rosetta.core.optimization.DOF_Node) → None¶

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.

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 &

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_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_object

initialize(self: pyrosetta.rosetta.core.optimization.DescentDirectionAlgorithm) → None¶: C++: core::optimization::DescentDirectionAlgorithm::initialize() –> void

class pyrosetta.rosetta.core.optimization.EItem¶

Bases: 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_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_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_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.

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

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

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_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: 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_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> &

link_torsion_vectors(self: pyrosetta.rosetta.core.optimization.MinimizerMap) → None¶

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_object

armijo_max_step_limit(*args, **kwargs)¶

Overloaded function.

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

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

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.

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

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

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.

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

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

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.

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

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

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.

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

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

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.

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

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

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.

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

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

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.

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

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.

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

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

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.

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

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

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

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

minimize_tolerance(*args, **kwargs)¶

Overloaded function.

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

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

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.

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

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

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.

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

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

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

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

use_nblist(*args, **kwargs)¶

Overloaded function.

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

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_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_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: SimpleDerivCheckResult

abs_deriv_dev(*args, **kwargs)¶

Overloaded function.

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

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.

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

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.

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

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

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.

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

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

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.

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

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

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.

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

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.

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

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.

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

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_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.

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

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

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_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_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_object

abs_deriv_dev(*args, **kwargs)¶

Overloaded function.

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

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.

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

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.

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

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

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.

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

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

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.

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

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

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.

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

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.

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

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: 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: 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.

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

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

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_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_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.

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
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
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