Package rosetta :: Package core :: Package optimization :: Module _core_optimization_
[hide private]
[frames] | no frames]

Module _core_optimization_

Classes [hide private]
  ArmijoLineMinimization
////////////////////////////////////////////////////// //////////////////////////////////////////////////////
  ArmijoLineMinimizationAP
  ArmijoLineMinimizationCAP
  AtomTreeMinimizer
High-level atom tree minimizer class
  AtomTreeMinimizerAP
  AtomTreeMinimizerCAP
  AtomTreeMultifunc
Atom tree multifunction class
  AtomTreeMultifuncAP
  AtomTreeMultifuncCAP
  BrentLineMinimization
////////////////////////////////////////////////////// //////////////////////////////////////////////////////
  BrentLineMinimizationAP
  BrentLineMinimizationCAP
  CartesianMinimizer
High-level atom tree minimizer class
  CartesianMinimizerAP
  CartesianMinimizerCAP
  CartesianMinimizerMap
core/optimization/CartesianMinimizerMap.hh:44
  CartesianMinimizerMapAP
  CartesianMinimizerMapCAP
  CartesianMultifunc
Atom tree multifunction class
  CartesianMultifuncAP
  CartesianMultifuncCAP
  ConvergenceTest
************************************************ * * 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.
  ConvergenceTestAP
  ConvergenceTestCAP
  DFPMinConvergedAbsolute
core/optimization/Minimizer.hh:75
  DFPMinConvergedAbsoluteAP
  DFPMinConvergedAbsoluteCAP
  DFPMinConvergedFractional
core/optimization/Minimizer.hh:64
  DFPMinConvergedFractionalAP
  DFPMinConvergedFractionalCAP
  DOF_DataPoint
core/optimization/NumericalDerivCheckResult.hh:132
  DOF_DataPointAP
  DOF_DataPointCAP
  DOF_Node
core/optimization/DOF_Node.hh:40
  DOF_NodeAP
  DOF_NodeCAP
  DerivCheckDataPoint
core/optimization/NumericalDerivCheckResult.hh:33
  DerivCheckDataPointAP
  DerivCheckDataPointCAP
  DescentDirectionAlgorithm
core/optimization/Minimizer.hh:93
  DescentDirectionAlgorithmAP
  DescentDirectionAlgorithmCAP
  EItem
Inner class for Genetic Algorithm, hold one population with some additional info
  EItemAP
  EItemCAP
  GA_Minimizer
core/optimization/GA_Minimizer.hh:47
  GA_MinimizerAP
  GA_MinimizerCAP
  JJH_Minimizer
core/optimization/Minimizer.hh:106
  JJH_MinimizerAP
  JJH_MinimizerCAP
  LineMinimizationAlgorithm
////////////////////////////////////////////////////// //////////////////////////////////////////////////////
  LineMinimizationAlgorithmAP
  LineMinimizationAlgorithmCAP
  Minimizer
Simple low-level minimizer class
  MinimizerAP
  MinimizerCAP
  MinimizerMap
core/optimization/MinimizerMap.hh:74
  MinimizerMapAP
  MinimizerMapCAP
  MinimizerOptions
core/optimization/MinimizerOptions.hh:31
  MinimizerOptionsAP
  MinimizerOptionsCAP
  Multifunc
Multifunction interface class
  MultifuncAP
  MultifuncCAP
  NelderMeadSimplex
core/optimization/NelderMeadSimplex.hh:29
  NelderMeadSimplexAP
  NelderMeadSimplexCAP
  NumDerivCheckData
core/optimization/NumericalDerivCheckResult.hh:194
  NumDerivCheckDataAP
  NumDerivCheckDataCAP
  NumericalDerivCheckResult
core/optimization/NumericalDerivCheckResult.hh:223
  NumericalDerivCheckResultAP
  NumericalDerivCheckResultCAP
  Particle
Simple data container for PSO algorithm.
  ParticleAP
  ParticleCAP
  ParticleSwarmMinimizer
Particle Swarm Optimization engine.
  ParticleSwarmMinimizerAP
  ParticleSwarmMinimizerCAP
  SimpleDerivCheckResult
core/optimization/NumericalDerivCheckResult.hh:81
  SimpleDerivCheckResultAP
  SimpleDerivCheckResultCAP
  SingleResidueMultifunc
A streamlined AtomTreeMultifunc designed specifically for RTMIN.
  SingleResidueMultifuncAP
  SingleResidueMultifuncCAP
  StrongWolfeLineMinimization
////////////////////////////////////////////////////// //////////////////////////////////////////////////////
  StrongWolfeLineMinimizationAP
  StrongWolfeLineMinimizationCAP
  __CPP_ArmijoLineMinimization__
  __CPP_AtomTreeMinimizer__
  __CPP_AtomTreeMultifunc__
  __CPP_BrentLineMinimization__
  __CPP_CartesianMinimizerMap__
  __CPP_CartesianMinimizer__
  __CPP_CartesianMultifunc__
  __CPP_ConvergenceTest__
  __CPP_DFPMinConvergedAbsolute__
  __CPP_DFPMinConvergedFractional__
  __CPP_LineMinimizationAlgorithm__
  __CPP_MinimizerMap__
  __CPP_SingleResidueMultifunc__
  __CPP_StrongWolfeLineMinimization__
  func_1d
core/optimization/LineMinimizer.hh:38
  func_1dAP
  func_1dCAP
  lbfgs_iteration_data
core/optimization/Minimizer.hh:129
  lbfgs_iteration_dataAP
  lbfgs_iteration_dataCAP
Functions [hide private]
 
atom_tree_dfunc(...)
atom_tree_dfunc( (Pose)pose, (MinimizerMap)min_map, (ScoreFunction)scorefxn, (vector1_Real)vars, (vector1_Real)dE_dvars) -> None : core/optimization/atom_tree_minimize.hh:46
 
atom_tree_get_atompairE_deriv(...)
atom_tree_get_atompairE_deriv( (Pose)pose, (MinimizerMap)min_map, (ScoreFunction)scorefxn) -> None : core/optimization/atom_tree_minimize.hh:54
 
cart_numerical_derivative_check(...)
cart_numerical_derivative_check( (CartesianMinimizerMap)min_map, (CartesianMultifunc)func, (vector1_Real)start_vars, (vector1_Real)dE_dvars, (NumericalDerivCheckResult)deriv_check_result, (bool)verbose) -> None : core/optimization/cartesian_minimize.hh:73
 
cartesian_collect_atompairE_deriv(...)
cartesian_collect_atompairE_deriv( (Pose)pose, (CartesianMinimizerMap)min_map, (ScoreFunction)scorefxn, (vector1_Real)dE_dvars, (float)scale) -> None : core/optimization/cartesian_minimize.hh:62
 
cartesian_collect_torsional_deriv(...)
cartesian_collect_torsional_deriv( (Pose)pose, (CartesianMinimizerMap)min_map, (ScoreFunction)scorefxn, (vector1_Real)dE_dvars, (float)scale) -> None : core/optimization/cartesian_minimize.hh:53
 
cartesian_dfunc(...)
cartesian_dfunc( (Pose)pose, (CartesianMinimizerMap)min_map, (ScoreFunction)scorefxn, (vector1_Real)vars, (vector1_Real)dE_dvars) -> None : core/optimization/cartesian_minimize.hh:45
 
numerical_derivative_check(...)
numerical_derivative_check( (MinimizerMap)min_map, (Multifunc)func, (vector1_Real)start_vars, (vector1_Real)dE_dvars, (NumericalDerivCheckResult)deriv_check_result, (bool)verbose) -> None : core/optimization/atom_tree_minimize.hh:83
 
simple_numeric_deriv_check(...)
simple_numeric_deriv_check( (Multifunc)func, (vector1_Real)start_vars, (vector1_Real)dE_dvars, (bool)send_to_stdout, (bool)verbose [, (int)nsteps=5]) -> SimpleDerivCheckResult : Numeric deriv check for Multifuncs other than the AtomTreeMultifunc.
 
tors_deriv_to_cartesian(...)
tors_deriv_to_cartesian( (float)dE_dtor, (object)coords, (object)dE_dxs) -> None : core/optimization/cartesian_minimize.hh:79
 
torsional_derivative_from_cartesian_derivatives(...)
torsional_derivative_from_cartesian_derivatives( (Atom)atom, (DOF_Node)dof_node, (float)dof_deriv, (float)torsion_scale_factor) -> float : core/optimization/atom_tree_minimize.hh:62
Variables [hide private]
  __package__ = None
Function Details [hide private]

atom_tree_dfunc(...)

 

atom_tree_dfunc( (Pose)pose, (MinimizerMap)min_map, (ScoreFunction)scorefxn, (vector1_Real)vars, (vector1_Real)dE_dvars) -> None :
    core/optimization/atom_tree_minimize.hh:46

    C++ signature :
        void atom_tree_dfunc(core::pose::Pose {lvalue},core::optimization::MinimizerMap {lvalue},core::scoring::ScoreFunction,utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> > {lvalue})

atom_tree_get_atompairE_deriv(...)

 

atom_tree_get_atompairE_deriv( (Pose)pose, (MinimizerMap)min_map, (ScoreFunction)scorefxn) -> None :
    core/optimization/atom_tree_minimize.hh:54

    C++ signature :
        void atom_tree_get_atompairE_deriv(core::pose::Pose {lvalue},core::optimization::MinimizerMap {lvalue},core::scoring::ScoreFunction)

cart_numerical_derivative_check(...)

 

cart_numerical_derivative_check( (CartesianMinimizerMap)min_map, (CartesianMultifunc)func, (vector1_Real)start_vars, (vector1_Real)dE_dvars, (NumericalDerivCheckResult)deriv_check_result, (bool)verbose) -> None :
    core/optimization/cartesian_minimize.hh:73

    C++ signature :
        void cart_numerical_derivative_check(core::optimization::CartesianMinimizerMap,core::optimization::CartesianMultifunc,utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >,boost::shared_ptr<core::optimization::NumericalDerivCheckResult>,bool)

cartesian_collect_atompairE_deriv(...)

 

cartesian_collect_atompairE_deriv( (Pose)pose, (CartesianMinimizerMap)min_map, (ScoreFunction)scorefxn, (vector1_Real)dE_dvars, (float)scale) -> None :
    core/optimization/cartesian_minimize.hh:62

    C++ signature :
        void cartesian_collect_atompairE_deriv(core::pose::Pose {lvalue},core::optimization::CartesianMinimizerMap {lvalue},core::scoring::ScoreFunction,utility::vector1<double, std::allocator<double> > {lvalue},double)

cartesian_collect_torsional_deriv(...)

 

cartesian_collect_torsional_deriv( (Pose)pose, (CartesianMinimizerMap)min_map, (ScoreFunction)scorefxn, (vector1_Real)dE_dvars, (float)scale) -> None :
    core/optimization/cartesian_minimize.hh:53

    C++ signature :
        void cartesian_collect_torsional_deriv(core::pose::Pose {lvalue},core::optimization::CartesianMinimizerMap {lvalue},core::scoring::ScoreFunction,utility::vector1<double, std::allocator<double> > {lvalue},double)

cartesian_dfunc(...)

 

cartesian_dfunc( (Pose)pose, (CartesianMinimizerMap)min_map, (ScoreFunction)scorefxn, (vector1_Real)vars, (vector1_Real)dE_dvars) -> None :
    core/optimization/cartesian_minimize.hh:45

    C++ signature :
        void cartesian_dfunc(core::pose::Pose {lvalue},core::optimization::CartesianMinimizerMap {lvalue},core::scoring::ScoreFunction,utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> > {lvalue})

numerical_derivative_check(...)

 

numerical_derivative_check( (MinimizerMap)min_map, (Multifunc)func, (vector1_Real)start_vars, (vector1_Real)dE_dvars, (NumericalDerivCheckResult)deriv_check_result, (bool)verbose) -> None :
    core/optimization/atom_tree_minimize.hh:83

    C++ signature :
        void numerical_derivative_check(core::optimization::MinimizerMap,core::optimization::Multifunc,utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >,boost::shared_ptr<core::optimization::NumericalDerivCheckResult>,bool)

simple_numeric_deriv_check(...)

 

simple_numeric_deriv_check( (Multifunc)func, (vector1_Real)start_vars, (vector1_Real)dE_dvars, (bool)send_to_stdout, (bool)verbose [, (int)nsteps=5]) -> SimpleDerivCheckResult :
    Numeric deriv check for Multifuncs other than the AtomTreeMultifunc.
    

    C++ signature :
        core::optimization::SimpleDerivCheckResult simple_numeric_deriv_check(core::optimization::Multifunc,utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >,bool,bool [,unsigned long=5])

tors_deriv_to_cartesian(...)

 

tors_deriv_to_cartesian( (float)dE_dtor, (object)coords, (object)dE_dxs) -> None :
    core/optimization/cartesian_minimize.hh:79

    C++ signature :
        void tors_deriv_to_cartesian(double,boost::tuples::tuple<numeric::xyzVector<double>, numeric::xyzVector<double>, numeric::xyzVector<double>, numeric::xyzVector<double>, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>,boost::tuples::tuple<numeric::xyzVector<double>, numeric::xyzVector<double>, numeric::xyzVector<double>, numeric::xyzVector<double>, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type> {lvalue})

torsional_derivative_from_cartesian_derivatives(...)

 

torsional_derivative_from_cartesian_derivatives( (Atom)atom, (DOF_Node)dof_node, (float)dof_deriv, (float)torsion_scale_factor) -> float :
    core/optimization/atom_tree_minimize.hh:62

    C++ signature :
        double torsional_derivative_from_cartesian_derivatives(core::kinematics::tree::Atom,core::optimization::DOF_Node,double,double)