Bindings for core::scoring::methods namespace

Modules
		rosetta.core.scoring.methods.carbohydrates rosetta.core.scoring.methods.dfire

Classes
		builtins.object CartBondedParameters BBDepCartBondedParameters BBIndepCartBondedParameters EnergyMethod OneBodyEnergy ContextDependentOneBodyEnergy BurialEnergy CenRotEnvEnergy DNA_DihedralEnergy EnvEnergy EnvSmoothEnergy Fa_MbenvEnergy MembraneCbetaEnergy MembraneEnvEnergy MembraneEnvSmoothEnergy SmoothEnvEnergy ContextIndependentOneBodyEnergy FreeDOF_Energy NMerPSSMEnergy NMerRefEnergy NMerSVMEnergy OmegaTetherEnergy P_AA_Energy P_AA_pp_Energy P_AA_ss_Energy RamachandranEnergy ReferenceEnergy ReferenceEnergyNoncanonical RingClosureEnergy SequenceDependentRefEnergy SplitUnfoldedTwoBodyEnergy SymmetricLigandEnergy UnfoldedStateEnergy WaterAdductIntraEnergy YHHPlanarityEnergy pHEnergy TwoBodyEnergy LongRangeTwoBodyEnergy ContextDependentLRTwoBodyEnergy GenBornEnergy ContextIndependentLRTwoBodyEnergy CartesianBondedEnergy MultipoleElecEnergy PoissonBoltzmannEnergy RamaPreProEnergy SASAEnergy VdWTinkerEnergy ShortRangeTwoBodyEnergy ContextDependentTwoBodyEnergy FACTSEnergy Fa_MbsolvEnergy MembraneCenPairEnergy PairEnergy ContextIndependentTwoBodyEnergy CenHBEnergy CenPairEnergy CenRotPairEnergy CustomAtomPairEnergy DNA_BaseEnergy DNA_ReferenceEnergy GaussianOverlapEnergy GoapEnergy HybridVDW_Energy LK_PolarNonPolarEnergy LK_hack MMBondAngleEnergy MMBondLengthEnergy MMLJEnergyInter MMLJEnergyIntra MMTorsionEnergy PeptideBondEnergy ProClosureEnergy RamachandranEnergy2B SmoothCenPairEnergy SuckerEnergy WaterAdductHBondEnergy WholeStructureEnergy CenPairMotifDegreeEnergy CenPairMotifEnergy ChainbreakEnergy ChemicalShiftAnisotropyEnergy ContactOrderEnergy D2H_SA_Energy DNA_EnvPairEnergy DipolarCouplingEnergy DirectReadoutEnergy DistanceChainbreakEnergy IntermolEnergy LinearChainbreakEnergy MembraneEnvPenalties MembraneLipo MissingEnergy OtherPoseEnergy PackStatEnergy ProQ_Energy RG_Energy_Fast RG_LocalEnergy RMS_Energy ResidualDipolarCouplingEnergy ResidualDipolarCouplingEnergy_Rohl SA_Energy SSElementMotifContactEnergy SecondaryStructureEnergy EnergyMethodCreator BurialEnergyCreator CartesianBondedEnergyCreator CenHBEnergyCreator CenPairEnergyCreator CenPairMotifDegreeEnergyCreator CenPairMotifEnergyCreator CenRotEnvEnergyCreator CenRotPairEnergyCreator ChainbreakEnergyCreator ChemicalShiftAnisotropyEnergyCreator ContactOrderEnergyCreator CustomAtomPairEnergyCreator D2H_SA_EnergyCreator DNA_BaseEnergyCreator DNA_DihedralEnergyCreator DNA_EnvPairEnergyCreator DNA_ReferenceEnergyCreator DipolarCouplingEnergyCreator DirectReadoutEnergyCreator DistanceChainbreakEnergyCreator EnvEnergyCreator EnvSmoothEnergyCreator FACTSEnergyCreator Fa_MbenvEnergyCreator Fa_MbsolvEnergyCreator FreeDOF_EnergyCreator GaussianOverlapEnergyCreator GenBornEnergyCreator GoapEnergyCreator HybridVDW_EnergyCreator IntermolEnergyCreator LK_PolarNonPolarEnergyCreator LK_hackCreator LinearChainbreakEnergyCreator MMBondAngleEnergyCreator MMBondLengthEnergyCreator MMLJEnergyInterCreator MMLJEnergyIntraCreator MMTorsionEnergyCreator MembraneCbetaEnergyCreator MembraneCenPairEnergyCreator MembraneEnvEnergyCreator MembraneEnvPenaltiesCreator MembraneEnvSmoothEnergyCreator MembraneLipoCreator MissingEnergyCreator MultipoleElecEnergyCreator NMerPSSMEnergyCreator NMerRefEnergyCreator NMerSVMEnergyCreator OmegaTetherEnergyCreator OtherPoseEnergyCreator P_AA_EnergyCreator P_AA_pp_EnergyCreator P_AA_ss_EnergyCreator PackStatEnergyCreator PairEnergyCreator PeptideBondEnergyCreator PoissonBoltzmannEnergyCreator ProClosureEnergyCreator ProQ_EnergyCreator RG_Energy_FastCreator RG_LocalEnergyCreator RMS_EnergyCreator RamaPreProEnergyCreator RamachandranEnergy2BCreator RamachandranEnergyCreator ReferenceEnergyCreator ReferenceEnergyNoncanonicalCreator ResidualDipolarCouplingEnergyCreator ResidualDipolarCouplingEnergy_RohlCreator RingClosureEnergyCreator SASAEnergyCreator SA_EnergyCreator SSElementMotifContactEnergyCreator SecondaryStructureEnergyCreator SequenceDependentRefEnergyCreator SmoothCenPairEnergyCreator SmoothEnvEnergyCreator SplitUnfoldedTwoBodyEnergyCreator SuckerEnergyCreator SymmetricLigandEnergyCreator UnfoldedStateEnergyCreator VdWTinkerEnergyCreator WaterAdductHBondEnergyCreator WaterAdductIntraEnergyCreator YHHPlanarityEnergyCreator pHEnergyCreator EnergyMethodOptions EnergyMethodType EnergyMethods FreeDOF_Options GoapRsdType IdealParametersDatabase LongRangeEnergyType PyEnergyMethodRegistrator ResidueCartBondedParameters rosetta.basic.datacache.CacheableData(builtins.object) NeighborListData PBLifetimeCache RG_MinData RG_Local_MinData   class BBDepCartBondedParameters(CartBondedParameters)       Method resolution order: BBDepCartBondedParameters CartBondedParameters builtins.object Methods defined here: K(...) from builtins.PyCapsule K(self : rosetta.core.scoring.methods.BBDepCartBondedParameters, phi : float, psi : float) -> float __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, ObjexxFCL::FArray2D<double>, ObjexxFCL::FArray2D<double>) -> NoneType   doc   3. __init__(self : handle, mu : ObjexxFCL::FArray2D<double>, Ks : ObjexxFCL::FArray2D<double>, tag_in : str) -> NoneType   4. __init__(handle, rosetta.core.scoring.methods.BBDepCartBondedParameters) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.BBDepCartBondedParameters,  : rosetta.core.scoring.methods.BBDepCartBondedParameters) -> rosetta.core.scoring.methods.BBDepCartBondedParameters dK_dphi(...) from builtins.PyCapsule dK_dphi(self : rosetta.core.scoring.methods.BBDepCartBondedParameters, phi : float, psi : float) -> float dK_dpsi(...) from builtins.PyCapsule dK_dpsi(self : rosetta.core.scoring.methods.BBDepCartBondedParameters, phi : float, psi : float) -> float dmu_dphi(...) from builtins.PyCapsule dmu_dphi(self : rosetta.core.scoring.methods.BBDepCartBondedParameters, phi : float, psi : float) -> float dmu_dpsi(...) from builtins.PyCapsule dmu_dpsi(self : rosetta.core.scoring.methods.BBDepCartBondedParameters, phi : float, psi : float) -> float init(...) from builtins.PyCapsule init(*args, **kwargs) Overloaded function.   1. init(self : rosetta.core.scoring.methods.BBDepCartBondedParameters, mu : ObjexxFCL::FArray2D<double>, Ks : ObjexxFCL::FArray2D<double>) -> NoneType   2. init(self : rosetta.core.scoring.methods.BBDepCartBondedParameters, x : rosetta.numeric.MathMatrix_double_t, x_spline : rosetta.numeric.interpolation.spline.BicubicSpline) -> NoneType mu(...) from builtins.PyCapsule mu(self : rosetta.core.scoring.methods.BBDepCartBondedParameters, phi : float, psi : float) -> float period(...) from builtins.PyCapsule period(rosetta.core.scoring.methods.BBDepCartBondedParameters) -> int Methods inherited from CartBondedParameters: is_null(...) from builtins.PyCapsule is_null(rosetta.core.scoring.methods.CartBondedParameters) -> bool   class BBIndepCartBondedParameters(CartBondedParameters)       Method resolution order: BBIndepCartBondedParameters CartBondedParameters builtins.object Methods defined here: K(...) from builtins.PyCapsule K(self : rosetta.core.scoring.methods.BBIndepCartBondedParameters,  : float,  : float) -> float __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, float, float) -> NoneType   doc   3. __init__(self : handle, mu0_in : float, K0_in : float, period_in : int) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.BBIndepCartBondedParameters,  : rosetta.core.scoring.methods.BBIndepCartBondedParameters) -> rosetta.core.scoring.methods.BBIndepCartBondedParameters is_null(...) from builtins.PyCapsule is_null(rosetta.core.scoring.methods.BBIndepCartBondedParameters) -> bool mu(...) from builtins.PyCapsule mu(self : rosetta.core.scoring.methods.BBIndepCartBondedParameters,  : float,  : float) -> float period(...) from builtins.PyCapsule period(rosetta.core.scoring.methods.BBIndepCartBondedParameters) -> int Methods inherited from CartBondedParameters: dK_dphi(...) from builtins.PyCapsule dK_dphi(self : rosetta.core.scoring.methods.CartBondedParameters,  : float,  : float) -> float dK_dpsi(...) from builtins.PyCapsule dK_dpsi(self : rosetta.core.scoring.methods.CartBondedParameters,  : float,  : float) -> float dmu_dphi(...) from builtins.PyCapsule dmu_dphi(self : rosetta.core.scoring.methods.CartBondedParameters,  : float,  : float) -> float dmu_dpsi(...) from builtins.PyCapsule dmu_dpsi(self : rosetta.core.scoring.methods.CartBondedParameters,  : float,  : float) -> float   class BurialEnergy(ContextDependentOneBodyEnergy)       Method resolution order: BurialEnergy ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.BurialEnergy,  : rosetta.core.scoring.methods.BurialEnergy) -> rosetta.core.scoring.methods.BurialEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.BurialEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.BurialEnergy,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.BurialEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.BurialEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.BurialEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.BurialEnergy) -> int Methods inherited from ContextDependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class BurialEnergyCreator(EnergyMethodCreator)       Method resolution order: BurialEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.BurialEnergyCreator) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.BurialEnergyCreator,  : rosetta.core.scoring.methods.BurialEnergyCreator) -> rosetta.core.scoring.methods.BurialEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.BurialEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new BurialEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.BurialEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class CartBondedParameters(builtins.object)       Methods defined here: K(...) from builtins.PyCapsule K(self : rosetta.core.scoring.methods.CartBondedParameters, phi : float, psi : float) -> float __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.methods.CartBondedParameters) -> NoneType   2. __init__(rosetta.core.scoring.methods.CartBondedParameters, rosetta.core.scoring.methods.CartBondedParameters) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CartBondedParameters,  : rosetta.core.scoring.methods.CartBondedParameters) -> rosetta.core.scoring.methods.CartBondedParameters dK_dphi(...) from builtins.PyCapsule dK_dphi(self : rosetta.core.scoring.methods.CartBondedParameters,  : float,  : float) -> float dK_dpsi(...) from builtins.PyCapsule dK_dpsi(self : rosetta.core.scoring.methods.CartBondedParameters,  : float,  : float) -> float dmu_dphi(...) from builtins.PyCapsule dmu_dphi(self : rosetta.core.scoring.methods.CartBondedParameters,  : float,  : float) -> float dmu_dpsi(...) from builtins.PyCapsule dmu_dpsi(self : rosetta.core.scoring.methods.CartBondedParameters,  : float,  : float) -> float is_null(...) from builtins.PyCapsule is_null(rosetta.core.scoring.methods.CartBondedParameters) -> bool mu(...) from builtins.PyCapsule mu(self : rosetta.core.scoring.methods.CartBondedParameters, phi : float, psi : float) -> float period(...) from builtins.PyCapsule period(rosetta.core.scoring.methods.CartBondedParameters) -> int   class CartesianBondedEnergy(ContextIndependentLRTwoBodyEnergy)     ////////////////   the energy method     Method resolution order: CartesianBondedEnergy ContextIndependentLRTwoBodyEnergy LongRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.CartesianBondedEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CartesianBondedEnergy,  : rosetta.core.scoring.methods.CartesianBondedEnergy) -> rosetta.core.scoring.methods.CartesianBondedEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.CartesianBondedEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.CartesianBondedEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.CartesianBondedEnergy,  : rosetta.core.pose.Pose) -> bool defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.CartesianBondedEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.methods.CartesianBondedEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.CartesianBondedEnergy, rsd : rosetta.core.conformation.Residue, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.CartesianBondedEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.CartesianBondedEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.CartesianBondedEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData,  : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType idealize_proline_nvs(...) from builtins.PyCapsule idealize_proline_nvs(self : rosetta.core.scoring.methods.CartesianBondedEnergy, pose : rosetta.core.pose.Pose) -> NoneType   Idealize the virtual NV atom of every proline in the pose. This prevents innacurate pro-close scores when switching between cartesian and non-cartesian score functions. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.CartesianBondedEnergy,  : rosetta.utility.vector1_bool) -> NoneType long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.methods.CartesianBondedEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.CartesianBondedEnergy,  : rosetta.core.pose.Pose) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.CartesianBondedEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.CartesianBondedEnergy, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.CartesianBondedEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextIndependentLRTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class CartesianBondedEnergyCreator(EnergyMethodCreator)       Method resolution order: CartesianBondedEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CartesianBondedEnergyCreator,  : rosetta.core.scoring.methods.CartesianBondedEnergyCreator) -> rosetta.core.scoring.methods.CartesianBondedEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.CartesianBondedEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new CartesianBondedEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.CartesianBondedEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class CenHBEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: CenHBEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.CenHBEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.CenHBEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.CenHBEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.CenHBEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.CenHBEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.CenHBEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType eval_residue_pair_derivatives_soft(...) from builtins.PyCapsule eval_residue_pair_derivatives_soft(self : rosetta.core.scoring.methods.CenHBEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.CenHBEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.CenHBEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.CenHBEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.CenHBEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class CenHBEnergyCreator(EnergyMethodCreator)       Method resolution order: CenHBEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CenHBEnergyCreator,  : rosetta.core.scoring.methods.CenHBEnergyCreator) -> rosetta.core.scoring.methods.CenHBEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.CenHBEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new CenHBEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.CenHBEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class CenPairEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: CenPairEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.CenPairEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.CenPairEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.CenPairEnergy,  : rosetta.core.scoring.EMapVector) -> bool   This method *should* admit to defining intraresidue energies eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.CenPairEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.CenPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.CenPairEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.CenPairEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.CenPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class CenPairEnergyCreator(EnergyMethodCreator)       Method resolution order: CenPairEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CenPairEnergyCreator,  : rosetta.core.scoring.methods.CenPairEnergyCreator) -> rosetta.core.scoring.methods.CenPairEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.CenPairEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new CenPairEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.CenPairEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class CenPairMotifDegreeEnergy(WholeStructureEnergy)       Method resolution order: CenPairMotifDegreeEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.CenPairMotifDegreeEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CenPairMotifDegreeEnergy,  : rosetta.core.scoring.methods.CenPairMotifDegreeEnergy) -> rosetta.core.scoring.methods.CenPairMotifDegreeEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.CenPairMotifDegreeEnergy) -> rosetta.core.scoring.methods.EnergyMethod finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.CenPairMotifDegreeEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   Called at the end of the energy evaluation. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.CenPairMotifDegreeEnergy,  : rosetta.utility.vector1_bool) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.CenPairMotifDegreeEnergy) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class CenPairMotifDegreeEnergyCreator(EnergyMethodCreator)       Method resolution order: CenPairMotifDegreeEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CenPairMotifDegreeEnergyCreator,  : rosetta.core.scoring.methods.CenPairMotifDegreeEnergyCreator) -> rosetta.core.scoring.methods.CenPairMotifDegreeEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.CenPairMotifDegreeEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MotifEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.CenPairMotifDegreeEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class CenPairMotifEnergy(WholeStructureEnergy)       Method resolution order: CenPairMotifEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.CenPairMotifEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CenPairMotifEnergy,  : rosetta.core.scoring.methods.CenPairMotifEnergy) -> rosetta.core.scoring.methods.CenPairMotifEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.CenPairMotifEnergy) -> rosetta.core.scoring.methods.EnergyMethod finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.CenPairMotifEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   Called at the end of the energy evaluation. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.CenPairMotifEnergy,  : rosetta.utility.vector1_bool) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.CenPairMotifEnergy) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class CenPairMotifEnergyCreator(EnergyMethodCreator)       Method resolution order: CenPairMotifEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CenPairMotifEnergyCreator,  : rosetta.core.scoring.methods.CenPairMotifEnergyCreator) -> rosetta.core.scoring.methods.CenPairMotifEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.CenPairMotifEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MotifEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.CenPairMotifEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class CenRotEnvEnergy(ContextDependentOneBodyEnergy)       Method resolution order: CenRotEnvEnergy ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.CenRotEnvEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.CenRotEnvEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.CenRotEnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.CenRotEnvEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.CenRotEnvEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.CenRotEnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.CenRotEnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextDependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class CenRotEnvEnergyCreator(EnergyMethodCreator)       Method resolution order: CenRotEnvEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CenRotEnvEnergyCreator,  : rosetta.core.scoring.methods.CenRotEnvEnergyCreator) -> rosetta.core.scoring.methods.CenRotEnvEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.CenRotEnvEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new CenRotEnvEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.CenRotEnvEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class CenRotPairEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: CenRotPairEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.CenRotPairEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.CenRotPairEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.CenRotPairEnergy,  : rosetta.core.scoring.EMapVector) -> bool   This method *should* admit to defining intraresidue energies eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.CenRotPairEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.CenRotPairEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.CenRotPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.CenRotPairEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.CenRotPairEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.CenRotPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class CenRotPairEnergyCreator(EnergyMethodCreator)       Method resolution order: CenRotPairEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CenRotPairEnergyCreator,  : rosetta.core.scoring.methods.CenRotPairEnergyCreator) -> rosetta.core.scoring.methods.CenRotPairEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.CenRotPairEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new CenRotPairEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.CenRotPairEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ChainbreakEnergy(WholeStructureEnergy)     ChainbreakEnergy class iterates across all residues in finalize() and determines a penalty between residues i and i+1 across a cutpoint by how much their virtual atoms do not align.     Method resolution order: ChainbreakEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.ChainbreakEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ChainbreakEnergy,  : rosetta.core.scoring.methods.ChainbreakEnergy) -> rosetta.core.scoring.methods.ChainbreakEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.ChainbreakEnergy) -> rosetta.core.scoring.methods.EnergyMethod eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.ChainbreakEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Called during gradient-based minimization inside dfunc. finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.ChainbreakEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   Called at the end of the energy evaluation. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.ChainbreakEnergy,  : rosetta.utility.vector1_bool) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.ChainbreakEnergy) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class ChainbreakEnergyCreator(EnergyMethodCreator)       Method resolution order: ChainbreakEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ChainbreakEnergyCreator,  : rosetta.core.scoring.methods.ChainbreakEnergyCreator) -> rosetta.core.scoring.methods.ChainbreakEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.ChainbreakEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ChainbreakEnergy. score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.ChainbreakEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod that  this EnergyMethodCreator creates in its create_energy_method() function.   class ChemicalShiftAnisotropyEnergy(WholeStructureEnergy)       Method resolution order: ChemicalShiftAnisotropyEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergy,  : rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergy) -> rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergy) -> rosetta.core.scoring.methods.EnergyMethod eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergy,  : rosetta.utility.vector1_bool) -> NoneType setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergy,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergy,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ChemicalShiftAnisotropyEnergyCreator(EnergyMethodCreator)       Method resolution order: ChemicalShiftAnisotropyEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergyCreator,  : rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergyCreator) -> rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ChemicalShiftAnisotropyEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.ChemicalShiftAnisotropyEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ContactOrderEnergy(WholeStructureEnergy)       Method resolution order: ContactOrderEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContactOrderEnergy,  : rosetta.core.scoring.methods.ContactOrderEnergy) -> rosetta.core.scoring.methods.ContactOrderEnergy calculate_contact_order(...) from builtins.PyCapsule calculate_contact_order(self : rosetta.core.scoring.methods.ContactOrderEnergy, pose : rosetta.core.pose.Pose) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.ContactOrderEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.ContactOrderEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.ContactOrderEnergy,  : rosetta.utility.vector1_bool) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.ContactOrderEnergy) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class ContactOrderEnergyCreator(EnergyMethodCreator)       Method resolution order: ContactOrderEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContactOrderEnergyCreator,  : rosetta.core.scoring.methods.ContactOrderEnergyCreator) -> rosetta.core.scoring.methods.ContactOrderEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.ContactOrderEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ContactOrderEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.ContactOrderEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ContextDependentLRTwoBodyEnergy(LongRangeTwoBodyEnergy)       Method resolution order: ContextDependentLRTwoBodyEnergy LongRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy,  : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy, rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from LongRangeTwoBodyEnergy: defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.methods.LongRangeTwoBodyEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.methods.LongRangeTwoBodyEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, weights : rosetta.core.scoring.EMapVector) -> bool   Two body energies are able to define intra-residue energies, and to do so  only in the presence of certain non-zero weights.  The ScoreFunction will hand over its  weight set as it asks whether the energy method defines an intraresidue energy or not.    For example, the Etable method defines intra-residue energies only when one or more  of the fa_intra_{atr,rep,sol} weights are non-zero. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between a given residue pair  accumulating the unweighted energies in an EnergyMap residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ContextDependentOneBodyEnergy(OneBodyEnergy)       Method resolution order: ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy,  : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy, rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ContextDependentTwoBodyEnergy(ShortRangeTwoBodyEnergy)       Method resolution order: ContextDependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy, creator : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy, rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff(). divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, weights : rosetta.core.scoring.EMapVector) -> bool   Two body energies are able to define intra-residue energies, and to do so  only in the presence of certain non-zero weights.  The ScoreFunction will hand over its  weight set as it asks whether the energy method defines an intraresidue energy or not.    For example, the Etable method defines intra-residue energies only when one or more  of the fa_intra_{atr,rep,sol} weights are non-zero. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between a given residue pair  accumulating the unweighted energies in an EnergyMap residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ContextIndependentLRTwoBodyEnergy(LongRangeTwoBodyEnergy)       Method resolution order: ContextIndependentLRTwoBodyEnergy LongRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy,  : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy, rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from LongRangeTwoBodyEnergy: defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.methods.LongRangeTwoBodyEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.methods.LongRangeTwoBodyEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, weights : rosetta.core.scoring.EMapVector) -> bool   Two body energies are able to define intra-residue energies, and to do so  only in the presence of certain non-zero weights.  The ScoreFunction will hand over its  weight set as it asks whether the energy method defines an intraresidue energy or not.    For example, the Etable method defines intra-residue energies only when one or more  of the fa_intra_{atr,rep,sol} weights are non-zero. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between a given residue pair  accumulating the unweighted energies in an EnergyMap residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ContextIndependentOneBodyEnergy(OneBodyEnergy)       Method resolution order: ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy,  : core::scoring::methods::EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy, rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ContextIndependentTwoBodyEnergy(ShortRangeTwoBodyEnergy)       Method resolution order: ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy, rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff(). divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, weights : rosetta.core.scoring.EMapVector) -> bool   Two body energies are able to define intra-residue energies, and to do so  only in the presence of certain non-zero weights.  The ScoreFunction will hand over its  weight set as it asks whether the energy method defines an intraresidue energy or not.    For example, the Etable method defines intra-residue energies only when one or more  of the fa_intra_{atr,rep,sol} weights are non-zero. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between a given residue pair  accumulating the unweighted energies in an EnergyMap residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class CustomAtomPairEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: CustomAtomPairEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, cst_seq_sep : int) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.CustomAtomPairEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.CustomAtomPairEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.CustomAtomPairEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.CustomAtomPairEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.CustomAtomPairEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.CustomAtomPairEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.CustomAtomPairEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType interaction_cutoff(...) from builtins.PyCapsule interaction_cutoff(rosetta.core.scoring.methods.CustomAtomPairEnergy) -> float   non-virtual accessor for speed prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.CustomAtomPairEnergy, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.CustomAtomPairEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.CustomAtomPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.CustomAtomPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.CustomAtomPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.CustomAtomPairEnergy,  : rosetta.core.pose.Pose, resid : int) -> NoneType Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class CustomAtomPairEnergyCreator(EnergyMethodCreator)       Method resolution order: CustomAtomPairEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.CustomAtomPairEnergyCreator,  : rosetta.core.scoring.methods.CustomAtomPairEnergyCreator) -> rosetta.core.scoring.methods.CustomAtomPairEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.CustomAtomPairEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new CustomAtomPairEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.CustomAtomPairEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class D2H_SA_Energy(WholeStructureEnergy)       Method resolution order: D2H_SA_Energy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.D2H_SA_Energy,  : rosetta.core.scoring.methods.D2H_SA_Energy) -> rosetta.core.scoring.methods.D2H_SA_Energy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.D2H_SA_Energy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.D2H_SA_Energy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.D2H_SA_Energy,  : rosetta.utility.vector1_bool) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.D2H_SA_Energy) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class D2H_SA_EnergyCreator(EnergyMethodCreator)       Method resolution order: D2H_SA_EnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.D2H_SA_EnergyCreator,  : rosetta.core.scoring.methods.D2H_SA_EnergyCreator) -> rosetta.core.scoring.methods.D2H_SA_EnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.D2H_SA_EnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new D2H_SA_Energy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.D2H_SA_EnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class DNA_BaseEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: DNA_BaseEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.DNA_BaseEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.DNA_BaseEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.DNA_BaseEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.DNA_BaseEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.DNA_BaseEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.DNA_BaseEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.DNA_BaseEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.DNA_BaseEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.DNA_BaseEnergy, pose : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.DNA_BaseEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class DNA_BaseEnergyCreator(EnergyMethodCreator)       Method resolution order: DNA_BaseEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.DNA_BaseEnergyCreator,  : rosetta.core.scoring.methods.DNA_BaseEnergyCreator) -> rosetta.core.scoring.methods.DNA_BaseEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.DNA_BaseEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new DNA_BaseEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.DNA_BaseEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class DNA_DihedralEnergy(ContextDependentOneBodyEnergy)       Method resolution order: DNA_DihedralEnergy ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.DNA_DihedralEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.DNA_DihedralEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone configure_from_options_system(...) from builtins.PyCapsule configure_from_options_system(rosetta.core.scoring.methods.DNA_DihedralEnergy) -> NoneType defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.DNA_DihedralEnergy,  : rosetta.core.pose.Pose) -> bool defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.DNA_DihedralEnergy,  : rosetta.core.conformation.Residue) -> bool eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.DNA_DihedralEnergy,  : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.DNA_DihedralEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   this function is used for the sugar derivs, which dont match up to a "torsion" in the current scheme eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.DNA_DihedralEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.DNA_DihedralEnergy,  : rosetta.utility.vector1_bool) -> NoneType   DNA_Dihedral Energy is context dependent, but indicates that no context graphs need to  be maintained by class Energies residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.DNA_DihedralEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.DNA_DihedralEnergy) -> int Methods inherited from ContextDependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class DNA_DihedralEnergyCreator(EnergyMethodCreator)       Method resolution order: DNA_DihedralEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.DNA_DihedralEnergyCreator,  : rosetta.core.scoring.methods.DNA_DihedralEnergyCreator) -> rosetta.core.scoring.methods.DNA_DihedralEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.DNA_DihedralEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new DNA_DihedralEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.DNA_DihedralEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class DNA_EnvPairEnergy(WholeStructureEnergy)     Implementation of env and pair terms for protein-DNA interactions     Could be a CI2B, but centroid atom is not currently the nbr atom for dna so intxn threshold tricky     Method resolution order: DNA_EnvPairEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.DNA_EnvPairEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.DNA_EnvPairEnergy, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   All the work happens here indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.DNA_EnvPairEnergy,  : rosetta.utility.vector1_bool) -> NoneType   No graphs required. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.DNA_EnvPairEnergy) -> int Methods inherited from WholeStructureEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WholeStructureEnergy,  : rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.WholeStructureEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class DNA_EnvPairEnergyCreator(EnergyMethodCreator)       Method resolution order: DNA_EnvPairEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.DNA_EnvPairEnergyCreator,  : rosetta.core.scoring.methods.DNA_EnvPairEnergyCreator) -> rosetta.core.scoring.methods.DNA_EnvPairEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.DNA_EnvPairEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new DNA_EnvPairEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.DNA_EnvPairEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class DNA_ReferenceEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: DNA_ReferenceEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.DNA_ReferenceEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.DNA_ReferenceEnergy,  : rosetta.core.scoring.methods.DNA_ReferenceEnergy) -> rosetta.core.scoring.methods.DNA_ReferenceEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.DNA_ReferenceEnergy) -> float base_step_energy(...) from builtins.PyCapsule base_step_energy(self : rosetta.core.scoring.methods.DNA_ReferenceEnergy, first_aa : rosetta.core.chemical.AA, second_aa : rosetta.core.chemical.AA) -> float   helper functions, possible used outside also clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.DNA_ReferenceEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone count_pair_bs(...) from builtins.PyCapsule count_pair_bs(self : rosetta.core.scoring.methods.DNA_ReferenceEnergy, pos1 : int, pos2 : int, partner : rosetta.core.scoring.dna.BasePartner) -> bool   ordered!!!! requires pos1<pos2 defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.DNA_ReferenceEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.DNA_ReferenceEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.DNA_ReferenceEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.DNA_ReferenceEnergy,  : rosetta.core.pose.Pose) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.DNA_ReferenceEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.DNA_ReferenceEnergy) -> int   Return the version of the energy method Methods inherited from ContextIndependentTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class DNA_ReferenceEnergyCreator(EnergyMethodCreator)       Method resolution order: DNA_ReferenceEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.DNA_ReferenceEnergyCreator,  : rosetta.core.scoring.methods.DNA_ReferenceEnergyCreator) -> rosetta.core.scoring.methods.DNA_ReferenceEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.DNA_ReferenceEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new DNA_DihedralEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.DNA_ReferenceEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class DipolarCouplingEnergy(WholeStructureEnergy)       Method resolution order: DipolarCouplingEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.DipolarCouplingEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.DipolarCouplingEnergy,  : rosetta.core.scoring.methods.DipolarCouplingEnergy) -> rosetta.core.scoring.methods.DipolarCouplingEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.DipolarCouplingEnergy) -> rosetta.core.scoring.methods.EnergyMethod eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.DipolarCouplingEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.DipolarCouplingEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.DipolarCouplingEnergy,  : rosetta.utility.vector1_bool) -> NoneType setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.DipolarCouplingEnergy,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.DipolarCouplingEnergy,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class DipolarCouplingEnergyCreator(EnergyMethodCreator)       Method resolution order: DipolarCouplingEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.DipolarCouplingEnergyCreator,  : rosetta.core.scoring.methods.DipolarCouplingEnergyCreator) -> rosetta.core.scoring.methods.DipolarCouplingEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.DipolarCouplingEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new DipolarCouplingEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.DipolarCouplingEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class DirectReadoutEnergy(WholeStructureEnergy)     Implementation of Kono and Sarai's knowledge-based protein-DNA interaction energy      Could be a CI2B, but interaction threshold is large, so in the short term defining as WholeStructure energy.     Method resolution order: DirectReadoutEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.DirectReadoutEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.DirectReadoutEnergy, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   All the work happens here indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.DirectReadoutEnergy,  : rosetta.utility.vector1_bool) -> NoneType   No graphs required. my_residue_pair_energy(...) from builtins.PyCapsule my_residue_pair_energy(self : rosetta.core.scoring.methods.DirectReadoutEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Implementation which is currently not used Methods inherited from WholeStructureEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WholeStructureEnergy,  : rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.WholeStructureEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class DirectReadoutEnergyCreator(EnergyMethodCreator)       Method resolution order: DirectReadoutEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.DirectReadoutEnergyCreator,  : rosetta.core.scoring.methods.DirectReadoutEnergyCreator) -> rosetta.core.scoring.methods.DirectReadoutEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.DirectReadoutEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new DirectReadoutEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.DirectReadoutEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class DistanceChainbreakEnergy(WholeStructureEnergy)     DistanceChainbreakEnergy class iterates across all residues in finalize() and determines the penalty between residues i and i+1 by how far apart their N and C atom are     Method resolution order: DistanceChainbreakEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.DistanceChainbreakEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.DistanceChainbreakEnergy,  : rosetta.core.scoring.methods.DistanceChainbreakEnergy) -> rosetta.core.scoring.methods.DistanceChainbreakEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.DistanceChainbreakEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.DistanceChainbreakEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   called at the end of energy evaluation indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.DistanceChainbreakEnergy,  : rosetta.utility.vector1_bool) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.DistanceChainbreakEnergy) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class DistanceChainbreakEnergyCreator(EnergyMethodCreator)       Method resolution order: DistanceChainbreakEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.DistanceChainbreakEnergyCreator,  : rosetta.core.scoring.methods.DistanceChainbreakEnergyCreator) -> rosetta.core.scoring.methods.DistanceChainbreakEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.DistanceChainbreakEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new DistanceChainbreakEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.DistanceChainbreakEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class EnergyMethod(builtins.object)     base class for the energy method hierarchy     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.EnergyMethod, creator : core::scoring::methods::EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.EnergyMethod, rosetta.core.scoring.methods.EnergyMethod) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethodType   Return one of the 7 kinds of energy methods that exist:  e.g. context-dependent-one-body vs whole-structure. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class EnergyMethodCreator(builtins.object)     The EnergyMethodCreator class's responsibilities are to create on demand a new EnergyMethod class, and to tell the ScoringManager singleton which ScoreTypes the EnergyMethod it creates is responsible for. The EnergyMethodCreator must register itself with the ScoringManager at load time (before main() begins) so that the ScoringManager is ready to start creating EnergyMethods by the time the first ScoreFunction requests one.     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.EnergyMethodCreator, rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.EnergyMethodCreator,  : rosetta.core.scoring.methods.EnergyMethodCreator) -> rosetta.core.scoring.methods.EnergyMethodCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.EnergyMethodCreator, options : core::scoring::methods::EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new EnergyMethod given a set of energy-method options score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.EnergyMethodCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class EnergyMethodOptions(builtins.object)     add more options here NOTE: If you add an option, make sure you also update the constructor, the assignment operator, the == comparison operator, and the show method in the .cc file! right now this class should be pretty light-weight since a copy is held inside ScoreFunctionInfo     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(self : rosetta.core.scoring.methods.EnergyMethodOptions, src : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.scoring.methods.EnergyMethodOptions) -> str aa_composition_setup_file(...) from builtins.PyCapsule aa_composition_setup_file(self : rosetta.core.scoring.methods.EnergyMethodOptions, index : int) -> str   Get the nth aa_composition setup file name from the list of setup files. aa_composition_setup_file_count(...) from builtins.PyCapsule aa_composition_setup_file_count(rosetta.core.scoring.methods.EnergyMethodOptions) -> int   Get the number of aa_composition setup files. analytic_etable_evaluation(...) from builtins.PyCapsule analytic_etable_evaluation(*args, **kwargs) Overloaded function.   1. analytic_etable_evaluation(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. analytic_etable_evaluation(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType append_aa_composition_setup_files(...) from builtins.PyCapsule append_aa_composition_setup_files(self : rosetta.core.scoring.methods.EnergyMethodOptions, input_filenames : rosetta.utility.vector1_std_string) -> NoneType   Appends additional files to the aa_composition setup file names.      Does not override existing. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.EnergyMethodOptions, src : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethodOptions   copy operator atom_vdw_atom_type_set_name(...) from builtins.PyCapsule atom_vdw_atom_type_set_name(*args, **kwargs) Overloaded function.   1. atom_vdw_atom_type_set_name(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   This is used in the construction of the VDW_Energy's AtomVDW object   2. atom_vdw_atom_type_set_name(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : str) -> NoneType bond_angle_central_atoms_to_score(...) from builtins.PyCapsule bond_angle_central_atoms_to_score(*args, **kwargs) Overloaded function.   1. bond_angle_central_atoms_to_score(rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.utility.vector1_std_string   deprecated   2. bond_angle_central_atoms_to_score(self : rosetta.core.scoring.methods.EnergyMethodOptions, atom_names : rosetta.utility.vector1_std_string) -> NoneType   depricated bond_angle_residue_type_param_set(...) from builtins.PyCapsule bond_angle_residue_type_param_set(*args, **kwargs) Overloaded function.   1. bond_angle_residue_type_param_set(rosetta.core.scoring.methods.EnergyMethodOptions) -> core::scoring::mm::MMBondAngleResidueTypeParamSet   2. bond_angle_residue_type_param_set(rosetta.core.scoring.methods.EnergyMethodOptions) -> core::scoring::mm::MMBondAngleResidueTypeParamSet   3. bond_angle_residue_type_param_set(self : rosetta.core.scoring.methods.EnergyMethodOptions, param_set : core::scoring::mm::MMBondAngleResidueTypeParamSet) -> NoneType clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethodOptions   clone cst_max_seq_sep(...) from builtins.PyCapsule cst_max_seq_sep(*args, **kwargs) Overloaded function.   1. cst_max_seq_sep(rosetta.core.scoring.methods.EnergyMethodOptions) -> int   2. cst_max_seq_sep(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : int) -> NoneType elec_die(...) from builtins.PyCapsule elec_die(*args, **kwargs) Overloaded function.   1. elec_die(rosetta.core.scoring.methods.EnergyMethodOptions) -> float   The dielectric used for the fa_elec term   2. elec_die(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : float) -> NoneType elec_group_file(...) from builtins.PyCapsule elec_group_file(*args, **kwargs) Overloaded function.   1. elec_group_file(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   2. elec_group_file(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : str) -> NoneType elec_max_dis(...) from builtins.PyCapsule elec_max_dis(*args, **kwargs) Overloaded function.   1. elec_max_dis(rosetta.core.scoring.methods.EnergyMethodOptions) -> float   The maximum (all atom) distance at which fa_elec is non-zero   2. elec_max_dis(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : float) -> NoneType elec_min_dis(...) from builtins.PyCapsule elec_min_dis(*args, **kwargs) Overloaded function.   1. elec_min_dis(rosetta.core.scoring.methods.EnergyMethodOptions) -> float   The minimium (all atom) distance for which fa_elec changes with distances   2. elec_min_dis(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : float) -> NoneType elec_no_dis_dep_die(...) from builtins.PyCapsule elec_no_dis_dep_die(*args, **kwargs) Overloaded function.   1. elec_no_dis_dep_die(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   Should fa_elec use a constant (non-distance dependant) dielectric?   2. elec_no_dis_dep_die(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType elec_sigmoidal_die(...) from builtins.PyCapsule elec_sigmoidal_die(*args, **kwargs) Overloaded function.   1. elec_sigmoidal_die(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   Should fa_elec/gpelec use a sigmoidal dielectric?   2. elec_sigmoidal_die(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType elec_sigmoidal_die_params(...) from builtins.PyCapsule elec_sigmoidal_die_params(self : rosetta.core.scoring.methods.EnergyMethodOptions, D : float, D0 : float, S : float) -> NoneType envsmooth_zero_negatives(...) from builtins.PyCapsule envsmooth_zero_negatives(*args, **kwargs) Overloaded function.   1. envsmooth_zero_negatives(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. envsmooth_zero_negatives(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType etable_options(...) from builtins.PyCapsule etable_options(*args, **kwargs) Overloaded function.   1. etable_options(rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.etable.EtableOptions   Read access to the etable options object   2. etable_options(rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.etable.EtableOptions   non-const access to the etable options object   3. etable_options(self : rosetta.core.scoring.methods.EnergyMethodOptions, opts : rosetta.core.scoring.etable.EtableOptions) -> NoneType   Set the etable options object -- makes a deep copy etable_type(...) from builtins.PyCapsule etable_type(*args, **kwargs) Overloaded function.   1. etable_type(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   2. etable_type(self : rosetta.core.scoring.methods.EnergyMethodOptions, type : str) -> NoneType exclude_DNA_DNA(...) from builtins.PyCapsule exclude_DNA_DNA(*args, **kwargs) Overloaded function.   1. exclude_DNA_DNA(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. exclude_DNA_DNA(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType exclude_intra_res_protein(...) from builtins.PyCapsule exclude_intra_res_protein(*args, **kwargs) Overloaded function.   1. exclude_intra_res_protein(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. exclude_intra_res_protein(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType exclude_monomer_fa_elec(...) from builtins.PyCapsule exclude_monomer_fa_elec(*args, **kwargs) Overloaded function.   1. exclude_monomer_fa_elec(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. exclude_monomer_fa_elec(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType exclude_protein_protein_fa_elec(...) from builtins.PyCapsule exclude_protein_protein_fa_elec(*args, **kwargs) Overloaded function.   1. exclude_protein_protein_fa_elec(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. exclude_protein_protein_fa_elec(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType free_dof_options(...) from builtins.PyCapsule free_dof_options(*args, **kwargs) Overloaded function.   1. free_dof_options(rosetta.core.scoring.methods.EnergyMethodOptions) -> core::scoring::methods::FreeDOF_Options   Read access to the FreeDOF options object   2. free_dof_options(rosetta.core.scoring.methods.EnergyMethodOptions) -> core::scoring::methods::FreeDOF_Options   non-const access to the FreeDOF options object   3. free_dof_options(self : rosetta.core.scoring.methods.EnergyMethodOptions, opts : core::scoring::methods::FreeDOF_Options) -> NoneType   Set the FreeDOF options object -- makes a deep copy geom_sol_interres_path_distance_cutoff(...) from builtins.PyCapsule geom_sol_interres_path_distance_cutoff(*args, **kwargs) Overloaded function.   1. geom_sol_interres_path_distance_cutoff(rosetta.core.scoring.methods.EnergyMethodOptions) -> int   2. geom_sol_interres_path_distance_cutoff(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : int) -> NoneType geom_sol_intrares_path_distance_cutoff(...) from builtins.PyCapsule geom_sol_intrares_path_distance_cutoff(*args, **kwargs) Overloaded function.   1. geom_sol_intrares_path_distance_cutoff(rosetta.core.scoring.methods.EnergyMethodOptions) -> int   2. geom_sol_intrares_path_distance_cutoff(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : int) -> NoneType get_cartesian_bonded_linear(...) from builtins.PyCapsule get_cartesian_bonded_linear(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   get the harmonic bond angle and bond-length spring constants get_cartesian_bonded_parameters(...) from builtins.PyCapsule get_cartesian_bonded_parameters(self : rosetta.core.scoring.methods.EnergyMethodOptions, len : float, ang : float, tors : float, proton : float, imp : float) -> NoneType   get the harmonic bond angle and bond-length spring constants get_density_sc_scale_byres(...) from builtins.PyCapsule get_density_sc_scale_byres(rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.utility.vector1_double grp_cpfxn(...) from builtins.PyCapsule grp_cpfxn(*args, **kwargs) Overloaded function.   1. grp_cpfxn(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. grp_cpfxn(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType grpelec_context_dependent(...) from builtins.PyCapsule grpelec_context_dependent(*args, **kwargs) Overloaded function.   1. grpelec_context_dependent(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. grpelec_context_dependent(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType grpelec_fade_hbond(...) from builtins.PyCapsule grpelec_fade_hbond(*args, **kwargs) Overloaded function.   1. grpelec_fade_hbond(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. grpelec_fade_hbond(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType grpelec_fade_param1(...) from builtins.PyCapsule grpelec_fade_param1(*args, **kwargs) Overloaded function.   1. grpelec_fade_param1(rosetta.core.scoring.methods.EnergyMethodOptions) -> float   2. grpelec_fade_param1(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : float) -> NoneType grpelec_fade_param2(...) from builtins.PyCapsule grpelec_fade_param2(*args, **kwargs) Overloaded function.   1. grpelec_fade_param2(rosetta.core.scoring.methods.EnergyMethodOptions) -> float   2. grpelec_fade_param2(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : float) -> NoneType grpelec_fade_type(...) from builtins.PyCapsule grpelec_fade_type(*args, **kwargs) Overloaded function.   1. grpelec_fade_type(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   2. grpelec_fade_type(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : str) -> NoneType has_method_weights(...) from builtins.PyCapsule has_method_weights(self : rosetta.core.scoring.methods.EnergyMethodOptions, type : rosetta.core.scoring.ScoreType) -> bool hbond_options(...) from builtins.PyCapsule hbond_options(*args, **kwargs) Overloaded function.   1. hbond_options(rosetta.core.scoring.methods.EnergyMethodOptions) -> core::scoring::hbonds::HBondOptions   Read access to the hbond options object   2. hbond_options(rosetta.core.scoring.methods.EnergyMethodOptions) -> core::scoring::hbonds::HBondOptions   non-const access to the hbond options object   3. hbond_options(self : rosetta.core.scoring.methods.EnergyMethodOptions, opts : core::scoring::hbonds::HBondOptions) -> NoneType   Set the hbond options object -- makes a deep copy initialize_from_options(...) from builtins.PyCapsule initialize_from_options(rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   Initialize a new EnergyMethodOptions with defaults from the command line. insert_score_function_method_options_rows(...) from builtins.PyCapsule insert_score_function_method_options_rows(self : rosetta.core.scoring.methods.EnergyMethodOptions, batch_id : int, score_function_name : str, db_session : rosetta.utility.sql_database.session) -> NoneType intrares_elec_correction_scale(...) from builtins.PyCapsule intrares_elec_correction_scale(*args, **kwargs) Overloaded function.   1. intrares_elec_correction_scale(rosetta.core.scoring.methods.EnergyMethodOptions) -> float   2. intrares_elec_correction_scale(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : float) -> NoneType method_weights(...) from builtins.PyCapsule method_weights(self : rosetta.core.scoring.methods.EnergyMethodOptions, type : rosetta.core.scoring.ScoreType) -> rosetta.utility.vector1_double pb_bound_tag(...) from builtins.PyCapsule pb_bound_tag(*args, **kwargs) Overloaded function.   1. pb_bound_tag(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   2. pb_bound_tag(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   3. pb_bound_tag(self : rosetta.core.scoring.methods.EnergyMethodOptions, tag : str) -> NoneType pb_unbound_tag(...) from builtins.PyCapsule pb_unbound_tag(*args, **kwargs) Overloaded function.   1. pb_unbound_tag(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   2. pb_unbound_tag(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   3. pb_unbound_tag(self : rosetta.core.scoring.methods.EnergyMethodOptions, tag : str) -> NoneType protein_dielectric(...) from builtins.PyCapsule protein_dielectric(*args, **kwargs) Overloaded function.   1. protein_dielectric(rosetta.core.scoring.methods.EnergyMethodOptions) -> float   2. protein_dielectric(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : float) -> NoneType put_intra_into_total(...) from builtins.PyCapsule put_intra_into_total(*args, **kwargs) Overloaded function.   1. put_intra_into_total(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. put_intra_into_total(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType rna_options(...) from builtins.PyCapsule rna_options(*args, **kwargs) Overloaded function.   1. rna_options(rosetta.core.scoring.methods.EnergyMethodOptions) -> core::scoring::rna::RNA_EnergyMethodOptions   Read access to the RNA options object   2. rna_options(rosetta.core.scoring.methods.EnergyMethodOptions) -> core::scoring::rna::RNA_EnergyMethodOptions   non-const access to the RNA options object   3. rna_options(self : rosetta.core.scoring.methods.EnergyMethodOptions, opts : core::scoring::rna::RNA_EnergyMethodOptions) -> NoneType   Set the FreeDOF options object -- makes a deep copy secondary_structure_weights(...) from builtins.PyCapsule secondary_structure_weights(*args, **kwargs) Overloaded function.   1. secondary_structure_weights(rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.SecondaryStructureWeights   2. secondary_structure_weights(rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.SecondaryStructureWeights set_aa_composition_setup_files(...) from builtins.PyCapsule set_aa_composition_setup_files(self : rosetta.core.scoring.methods.EnergyMethodOptions, input_filenames : rosetta.utility.vector1_std_string) -> NoneType   Set the aa_composition setup file names.      Overrides existing. set_cartesian_bonded_linear(...) from builtins.PyCapsule set_cartesian_bonded_linear(self : rosetta.core.scoring.methods.EnergyMethodOptions, lin_in : bool) -> NoneType   set the harmonic bond angle and bond-length spring constants set_cartesian_bonded_parameters(...) from builtins.PyCapsule set_cartesian_bonded_parameters(self : rosetta.core.scoring.methods.EnergyMethodOptions, len : float, ang : float, tors : float, proton : float, imp : float) -> NoneType   set the harmonic bond angle and bond-length spring constants set_density_sc_scale_byres(...) from builtins.PyCapsule set_density_sc_scale_byres(*args, **kwargs) Overloaded function.   1. set_density_sc_scale_byres(self : rosetta.core.scoring.methods.EnergyMethodOptions, newscscale : float) -> NoneType   2. set_density_sc_scale_byres(self : rosetta.core.scoring.methods.EnergyMethodOptions, aa : rosetta.core.chemical.AA, newscscale : float) -> NoneType set_elec_sigmoidal_die_params(...) from builtins.PyCapsule set_elec_sigmoidal_die_params(self : rosetta.core.scoring.methods.EnergyMethodOptions, D : float, D0 : float, S : float) -> NoneType set_method_weights(...) from builtins.PyCapsule set_method_weights(self : rosetta.core.scoring.methods.EnergyMethodOptions, type : rosetta.core.scoring.ScoreType, wts : rosetta.utility.vector1_double) -> NoneType set_strand_strand_weights(...) from builtins.PyCapsule set_strand_strand_weights(self : rosetta.core.scoring.methods.EnergyMethodOptions, ss_lowstrand : int, ss_cutoff : int) -> NoneType smooth_fa_elec(...) from builtins.PyCapsule smooth_fa_elec(*args, **kwargs) Overloaded function.   1. smooth_fa_elec(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. smooth_fa_elec(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType split_unfolded_label_type(...) from builtins.PyCapsule split_unfolded_label_type(*args, **kwargs) Overloaded function.   1. split_unfolded_label_type(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   2. split_unfolded_label_type(self : rosetta.core.scoring.methods.EnergyMethodOptions, label_type : str) -> NoneType split_unfolded_value_type(...) from builtins.PyCapsule split_unfolded_value_type(*args, **kwargs) Overloaded function.   1. split_unfolded_value_type(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   2. split_unfolded_value_type(self : rosetta.core.scoring.methods.EnergyMethodOptions, value_type : str) -> NoneType symmetric_gly_tables(...) from builtins.PyCapsule symmetric_gly_tables(*args, **kwargs) Overloaded function.   1. symmetric_gly_tables(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   Should glyceine's Ramachandran and P_AA_PP tables be symmetrized (e.g. for scoring in a mixed D/L context)?      Default false.      Vikram K. Mulligan (vmullig.edu)   2. symmetric_gly_tables(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType   Set whether glyceine's Ramachandran and P_AA_PP tables should be symmetrized (e.g. for scoring in a mixed D/L context).      Vikram K. Mulligan (vmullig.edu) unfolded_energies_type(...) from builtins.PyCapsule unfolded_energies_type(*args, **kwargs) Overloaded function.   1. unfolded_energies_type(rosetta.core.scoring.methods.EnergyMethodOptions) -> str   2. unfolded_energies_type(self : rosetta.core.scoring.methods.EnergyMethodOptions, type : str) -> NoneType use_gen_kirkwood(...) from builtins.PyCapsule use_gen_kirkwood(*args, **kwargs) Overloaded function.   1. use_gen_kirkwood(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. use_gen_kirkwood(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType use_polarization(...) from builtins.PyCapsule use_polarization(*args, **kwargs) Overloaded function.   1. use_polarization(rosetta.core.scoring.methods.EnergyMethodOptions) -> bool   2. use_polarization(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : bool) -> NoneType water_dielectric(...) from builtins.PyCapsule water_dielectric(*args, **kwargs) Overloaded function.   1. water_dielectric(rosetta.core.scoring.methods.EnergyMethodOptions) -> float   2. water_dielectric(self : rosetta.core.scoring.methods.EnergyMethodOptions, setting : float) -> NoneType write_score_function_method_options_table_schema(...) from builtins.PyCapsule write_score_function_method_options_table_schema(db_session : rosetta.utility.sql_database.session) -> NoneType   class EnergyMethodType(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.scoring.methods.EnergyMethodType, rosetta.core.scoring.methods.EnergyMethodType) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.scoring.methods.EnergyMethodType) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.methods.EnergyMethodType, int) -> NoneType   2. __init__(rosetta.core.scoring.methods.EnergyMethodType, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.scoring.methods.EnergyMethodType) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.scoring.methods.EnergyMethodType, rosetta.core.scoring.methods.EnergyMethodType) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.scoring.methods.EnergyMethodType) -> str Data and other attributes defined here: cd_1b = EnergyMethodType.cd_1b cd_2b = EnergyMethodType.cd_2b cd_lr_2b = EnergyMethodType.cd_lr_2b ci_1b = EnergyMethodType.ci_1b ci_2b = EnergyMethodType.ci_2b ci_lr_2b = EnergyMethodType.ci_lr_2b n_energy_method_types = EnergyMethodType.n_energy_method_types ws = EnergyMethodType.n_energy_method_types   class EnergyMethods(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.scoring.methods.EnergyMethods, rosetta.core.scoring.methods.EnergyMethods) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.scoring.methods.EnergyMethods) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.methods.EnergyMethods, int) -> NoneType   2. __init__(rosetta.core.scoring.methods.EnergyMethods, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.scoring.methods.EnergyMethods) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.scoring.methods.EnergyMethods, rosetta.core.scoring.methods.EnergyMethods) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.scoring.methods.EnergyMethods) -> str Data and other attributes defined here: dunbrack_method = EnergyMethods.dunbrack_method elec_method = EnergyMethods.elec_method etable_method = EnergyMethods.etable_method hbond_method = EnergyMethods.hbond_method lkball_method = EnergyMethods.lkball_method mm_lj_energy_inter_method = EnergyMethods.mm_lj_energy_inter_method n_energy_methods = EnergyMethods.n_energy_methods pair_e_method = EnergyMethods.pair_e_method ramachandran_method = EnergyMethods.n_energy_methods reference_e_method = EnergyMethods.reference_e_method vdw_method = EnergyMethods.vdw_method   class EnvEnergy(ContextDependentOneBodyEnergy)       Method resolution order: EnvEnergy ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnvEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnvEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.EnvEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextDependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class EnvEnergyCreator(EnergyMethodCreator)       Method resolution order: EnvEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.EnvEnergyCreator,  : rosetta.core.scoring.methods.EnvEnergyCreator) -> rosetta.core.scoring.methods.EnvEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.EnvEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new EnvEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.EnvEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class EnvSmoothEnergy(ContextDependentOneBodyEnergy)       Method resolution order: EnvSmoothEnergy ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.EnvSmoothEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.EnvSmoothEnergy,  : rosetta.core.scoring.methods.EnvSmoothEnergy) -> rosetta.core.scoring.methods.EnvSmoothEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.EnvSmoothEnergy) -> float   unused by the EnvSmoothEnergy class, returns 0 clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnvSmoothEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnvSmoothEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose,  : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   increments the F1 and F2 derivative vectors for an atom indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnvSmoothEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Tells the scoring function to maintain the TwelveANeighborGraph residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.EnvSmoothEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.EMapVector) -> NoneType   evaluates the one-body energy for a residue setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnvSmoothEnergy, pose : rosetta.core.pose.Pose, sf : rosetta.core.scoring.ScoreFunction) -> NoneType   causes a neighbor graph update setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnvSmoothEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   computes dScore/dNumNeighbors for all residues for rapid use in later  atom derivate calculations Methods inherited from ContextDependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class EnvSmoothEnergyCreator(EnergyMethodCreator)       Method resolution order: EnvSmoothEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.EnvSmoothEnergyCreator,  : rosetta.core.scoring.methods.EnvSmoothEnergyCreator) -> rosetta.core.scoring.methods.EnvSmoothEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.EnvSmoothEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new EnvSmoothEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.EnvSmoothEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class FACTSEnergy(ContextDependentTwoBodyEnergy)       Method resolution order: FACTSEnergy ContextDependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.FACTSEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.FACTSEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.FACTSEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.FACTSEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.FACTSEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.FACTSEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.FACTSEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.FACTSEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.FACTSEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.FACTSEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.FACTSEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.FACTSEnergy,  : rosetta.utility.vector1_bool) -> NoneType packing_interaction_cutoff(...) from builtins.PyCapsule packing_interaction_cutoff(rosetta.core.scoring.methods.FACTSEnergy) -> float   this is our own special function prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.FACTSEnergy, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.FACTSEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.FACTSEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.FACTSEnergy, pose : rosetta.core.pose.Pose, residues_repacking : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.FACTSEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.FACTSEnergy,  : rosetta.core.pose.Pose, resid : int) -> NoneType Methods inherited from ContextDependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class FACTSEnergyCreator(EnergyMethodCreator)       Method resolution order: FACTSEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.FACTSEnergyCreator,  : rosetta.core.scoring.methods.FACTSEnergyCreator) -> rosetta.core.scoring.methods.FACTSEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.FACTSEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new GenBornEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.FACTSEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class Fa_MbenvEnergy(ContextDependentOneBodyEnergy)       Method resolution order: Fa_MbenvEnergy ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: MembraneEmbed_from_pose(...) from builtins.PyCapsule MembraneEmbed_from_pose(self : rosetta.core.scoring.methods.Fa_MbenvEnergy,  : rosetta.core.pose.Pose) -> rosetta.core.scoring.MembraneEmbed MembraneTopology_from_pose(...) from builtins.PyCapsule MembraneTopology_from_pose(self : rosetta.core.scoring.methods.Fa_MbenvEnergy,  : rosetta.core.pose.Pose) -> rosetta.core.scoring.MembraneTopology Membrane_FAEmbed_from_pose(...) from builtins.PyCapsule Membrane_FAEmbed_from_pose(self : rosetta.core.scoring.methods.Fa_MbenvEnergy,  : rosetta.core.pose.Pose) -> rosetta.core.scoring.Membrane_FAEmbed __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, memb_etable_in : rosetta.core.scoring.etable.MembEtable) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.Fa_MbenvEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.Fa_MbenvEnergy) -> rosetta.core.scoring.methods.EnergyMethod eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.Fa_MbenvEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.Fa_MbenvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.Fa_MbenvEnergy,  : rosetta.utility.vector1_bool) -> NoneType   Fa_MbenvEnergy is context independent; indicates that no context graphs are required residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.Fa_MbenvEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.Fa_MbenvEnergy, pose : rosetta.core.pose.Pose, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.Fa_MbenvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextDependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class Fa_MbenvEnergyCreator(EnergyMethodCreator)       Method resolution order: Fa_MbenvEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.Fa_MbenvEnergyCreator,  : rosetta.core.scoring.methods.Fa_MbenvEnergyCreator) -> rosetta.core.scoring.methods.Fa_MbenvEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.Fa_MbenvEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new Fa_MbenvEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.Fa_MbenvEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class Fa_MbsolvEnergy(ContextDependentTwoBodyEnergy)       Method resolution order: Fa_MbsolvEnergy ContextDependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: MembraneTopology_from_pose(...) from builtins.PyCapsule MembraneTopology_from_pose(self : rosetta.core.scoring.methods.Fa_MbsolvEnergy, pose : rosetta.core.pose.Pose) -> rosetta.core.scoring.MembraneTopology Membrane_FAEmbed_from_pose(...) from builtins.PyCapsule Membrane_FAEmbed_from_pose(self : rosetta.core.scoring.methods.Fa_MbsolvEnergy, pose : rosetta.core.pose.Pose) -> rosetta.core.scoring.Membrane_FAEmbed __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, etable_in : rosetta.core.scoring.etable.Etable, memb_etable_in : rosetta.core.scoring.etable.MembEtable) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.Fa_MbsolvEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.Fa_MbsolvEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.Fa_MbsolvEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.Fa_MbsolvEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.Fa_MbsolvEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   called during gradient-based minimization inside dfunc           F1 and F2 are not zeroed -- contributions from this atom are         just summed in eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.Fa_MbsolvEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.Fa_MbsolvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.Fa_MbsolvEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.Fa_MbsolvEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.Fa_MbsolvEnergy, pose : rosetta.core.pose.Pose, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.Fa_MbsolvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextDependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class Fa_MbsolvEnergyCreator(EnergyMethodCreator)       Method resolution order: Fa_MbsolvEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.Fa_MbsolvEnergyCreator,  : rosetta.core.scoring.methods.Fa_MbsolvEnergyCreator) -> rosetta.core.scoring.methods.Fa_MbsolvEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.Fa_MbsolvEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new Fa_MbsolvEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.Fa_MbsolvEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class FreeDOF_Energy(ContextIndependentOneBodyEnergy)       Method resolution order: FreeDOF_Energy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(self : handle, energy_method_options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.FreeDOF_Energy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.FreeDOF_Energy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.FreeDOF_Energy,  : rosetta.utility.vector1_bool) -> NoneType   FreeDOF_Energy is context independent; indicates that no  context graphs are required residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.FreeDOF_Energy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.FreeDOF_Energy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.FreeDOF_Energy) -> int Methods inherited from ContextIndependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class FreeDOF_EnergyCreator(EnergyMethodCreator)       Method resolution order: FreeDOF_EnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.FreeDOF_EnergyCreator,  : rosetta.core.scoring.methods.FreeDOF_EnergyCreator) -> rosetta.core.scoring.methods.FreeDOF_EnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.FreeDOF_EnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new FreeDOF_Energy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.FreeDOF_EnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class FreeDOF_Options(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.scoring.methods.FreeDOF_Options) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.scoring.methods.FreeDOF_Options) -> str assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.FreeDOF_Options,  : rosetta.core.scoring.methods.FreeDOF_Options) -> rosetta.core.scoring.methods.FreeDOF_Options free_2HOprime_bonus(...) from builtins.PyCapsule free_2HOprime_bonus(*args, **kwargs) Overloaded function.   1. free_2HOprime_bonus(rosetta.core.scoring.methods.FreeDOF_Options) -> float   2. free_2HOprime_bonus(self : rosetta.core.scoring.methods.FreeDOF_Options, setting : float) -> NoneType free_side_chain_bonus(...) from builtins.PyCapsule free_side_chain_bonus(*args, **kwargs) Overloaded function.   1. free_side_chain_bonus(rosetta.core.scoring.methods.FreeDOF_Options) -> float   2. free_side_chain_bonus(self : rosetta.core.scoring.methods.FreeDOF_Options, setting : float) -> NoneType free_sugar_bonus(...) from builtins.PyCapsule free_sugar_bonus(*args, **kwargs) Overloaded function.   1. free_sugar_bonus(rosetta.core.scoring.methods.FreeDOF_Options) -> float   2. free_sugar_bonus(self : rosetta.core.scoring.methods.FreeDOF_Options, setting : float) -> NoneType free_suite_bonus(...) from builtins.PyCapsule free_suite_bonus(*args, **kwargs) Overloaded function.   1. free_suite_bonus(rosetta.core.scoring.methods.FreeDOF_Options) -> float   2. free_suite_bonus(self : rosetta.core.scoring.methods.FreeDOF_Options, setting : float) -> NoneType initialize_from_options(...) from builtins.PyCapsule initialize_from_options(rosetta.core.scoring.methods.FreeDOF_Options) -> NoneType pack_phosphate_penalty(...) from builtins.PyCapsule pack_phosphate_penalty(*args, **kwargs) Overloaded function.   1. pack_phosphate_penalty(rosetta.core.scoring.methods.FreeDOF_Options) -> float   2. pack_phosphate_penalty(self : rosetta.core.scoring.methods.FreeDOF_Options, setting : float) -> NoneType   class GaussianOverlapEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: GaussianOverlapEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.GaussianOverlapEnergy,  : rosetta.core.scoring.methods.GaussianOverlapEnergy) -> rosetta.core.scoring.methods.GaussianOverlapEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.GaussianOverlapEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.GaussianOverlapEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.GaussianOverlapEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.GaussianOverlapEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.GaussianOverlapEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.GaussianOverlapEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType interaction_cutoff(...) from builtins.PyCapsule interaction_cutoff(rosetta.core.scoring.methods.GaussianOverlapEnergy) -> float   non-virtual accessor for speed residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.GaussianOverlapEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class GaussianOverlapEnergyCreator(EnergyMethodCreator)       Method resolution order: GaussianOverlapEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.GaussianOverlapEnergyCreator,  : rosetta.core.scoring.methods.GaussianOverlapEnergyCreator) -> rosetta.core.scoring.methods.GaussianOverlapEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.GaussianOverlapEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new GaussianOverlapEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.GaussianOverlapEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class GenBornEnergy(ContextDependentLRTwoBodyEnergy)       Method resolution order: GenBornEnergy ContextDependentLRTwoBodyEnergy LongRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.GenBornEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.GenBornEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.GenBornEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.methods.GenBornEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.GenBornEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.GenBornEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.GenBornEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.GenBornEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.GenBornEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.GenBornEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.GenBornEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.GenBornEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.methods.GenBornEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType packing_interaction_cutoff(...) from builtins.PyCapsule packing_interaction_cutoff(rosetta.core.scoring.methods.GenBornEnergy) -> float   this is our own special function prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.GenBornEnergy, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.GenBornEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.GenBornEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.GenBornEnergy, pose : rosetta.core.pose.Pose, residues_repacking : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.GenBornEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.GenBornEnergy,  : rosetta.core.pose.Pose, resid : int) -> NoneType Methods inherited from ContextDependentLRTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class GenBornEnergyCreator(EnergyMethodCreator)       Method resolution order: GenBornEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.GenBornEnergyCreator,  : rosetta.core.scoring.methods.GenBornEnergyCreator) -> rosetta.core.scoring.methods.GenBornEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.GenBornEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new GenBornEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.GenBornEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class GoapEnergy(ContextIndependentTwoBodyEnergy)     /////////////////////////////////////////////////////     Method resolution order: GoapEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.GoapEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.GoapEnergy,  : rosetta.core.scoring.methods.GoapEnergy) -> rosetta.core.scoring.methods.GoapEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.GoapEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.GoapEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone continuous(...) from builtins.PyCapsule continuous(rosetta.core.scoring.methods.GoapEnergy) -> bool defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.GoapEnergy,  : rosetta.core.scoring.EMapVector) -> bool distbin_map(...) from builtins.PyCapsule distbin_map(self : rosetta.core.scoring.methods.GoapEnergy, i : int) -> int eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.GoapEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType eval_res(...) from builtins.PyCapsule eval_res(self : rosetta.core.scoring.methods.GoapEnergy, resno : int) -> bool eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.GoapEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResPairMinimizationData,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.EMapVector,  : rosetta.utility.vector1_core_scoring_DerivVectorPair,  : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.GoapEnergy,  : rosetta.utility.vector1_bool) -> NoneType max_dis(...) from builtins.PyCapsule max_dis(rosetta.core.scoring.methods.GoapEnergy) -> float minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.GoapEnergy,  : rosetta.core.pose.Pose) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.GoapEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.GoapEnergy,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.GoapEnergy,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.GoapEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.GoapEnergy) -> int xd(...) from builtins.PyCapsule xd(self : rosetta.core.scoring.methods.GoapEnergy, resno : int, atmno : int) -> rosetta.numeric.xyzVector_double_t xn(...) from builtins.PyCapsule xn(self : rosetta.core.scoring.methods.GoapEnergy, resno : int, atmno : int) -> rosetta.numeric.xyzVector_double_t Methods inherited from ContextIndependentTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class GoapEnergyCreator(EnergyMethodCreator)       Method resolution order: GoapEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.GoapEnergyCreator,  : rosetta.core.scoring.methods.GoapEnergyCreator) -> rosetta.core.scoring.methods.GoapEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.GoapEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new GoapEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.GoapEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class GoapRsdType(builtins.object)     /////////////////////////////////////////////////////     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.methods.GoapRsdType) -> NoneType   2. __init__(self : rosetta.core.scoring.methods.GoapRsdType,  : rosetta.core.scoring.methods.GoapRsdType) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_atmname_using(...) from builtins.PyCapsule add_atmname_using(self : rosetta.core.scoring.methods.GoapRsdType, str : str) -> NoneType assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.GoapRsdType,  : rosetta.core.scoring.methods.GoapRsdType) -> rosetta.core.scoring.methods.GoapRsdType atmid(...) from builtins.PyCapsule atmid(self : rosetta.core.scoring.methods.GoapRsdType, i : int) -> int atmname_using(...) from builtins.PyCapsule atmname_using(self : rosetta.core.scoring.methods.GoapRsdType, i : int) -> str connected_by_twobonds(...) from builtins.PyCapsule connected_by_twobonds(self : rosetta.core.scoring.methods.GoapRsdType, i : int) -> bool i2(...) from builtins.PyCapsule i2(self : rosetta.core.scoring.methods.GoapRsdType, i : int) -> int i3(...) from builtins.PyCapsule i3(self : rosetta.core.scoring.methods.GoapRsdType, i : int) -> int is_using(...) from builtins.PyCapsule is_using(self : rosetta.core.scoring.methods.GoapRsdType, i : int) -> bool name(...) from builtins.PyCapsule name(rosetta.core.scoring.methods.GoapRsdType) -> str natom(...) from builtins.PyCapsule natom(rosetta.core.scoring.methods.GoapRsdType) -> int nusing(...) from builtins.PyCapsule nusing(rosetta.core.scoring.methods.GoapRsdType) -> int set_angle_atom(...) from builtins.PyCapsule set_angle_atom(self : rosetta.core.scoring.methods.GoapRsdType, i : int, j : int) -> NoneType set_atmid(...) from builtins.PyCapsule set_atmid(self : rosetta.core.scoring.methods.GoapRsdType, i : int, j : int) -> NoneType set_branch_atom(...) from builtins.PyCapsule set_branch_atom(self : rosetta.core.scoring.methods.GoapRsdType, i : int, j : int) -> NoneType set_root_atom(...) from builtins.PyCapsule set_root_atom(self : rosetta.core.scoring.methods.GoapRsdType, i : int, j : int) -> NoneType set_using(...) from builtins.PyCapsule set_using(self : rosetta.core.scoring.methods.GoapRsdType, i : int, val : bool) -> NoneType setup_connectivity(...) from builtins.PyCapsule setup_connectivity(self : rosetta.core.scoring.methods.GoapRsdType, rsd : rosetta.core.chemical.ResidueType) -> NoneType setup_rsdtype(...) from builtins.PyCapsule setup_rsdtype(self : rosetta.core.scoring.methods.GoapRsdType, rsd : rosetta.core.chemical.ResidueType) -> NoneType   class HybridVDW_Energy(ContextIndependentTwoBodyEnergy)       Method resolution order: HybridVDW_Energy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.HybridVDW_Energy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.HybridVDW_Energy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.HybridVDW_Energy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.HybridVDW_Energy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.HybridVDW_Energy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, scorefxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.HybridVDW_Energy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.HybridVDW_Energy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.HybridVDW_Energy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.HybridVDW_Energy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.HybridVDW_Energy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class HybridVDW_EnergyCreator(EnergyMethodCreator)       Method resolution order: HybridVDW_EnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.HybridVDW_EnergyCreator,  : rosetta.core.scoring.methods.HybridVDW_EnergyCreator) -> rosetta.core.scoring.methods.HybridVDW_EnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.HybridVDW_EnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new HybridVDW_Energy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.HybridVDW_EnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class IdealParametersDatabase(builtins.object)     /////////////////     Methods defined here: __init__(...) from builtins.PyCapsule __init__(self : rosetta.core.scoring.methods.IdealParametersDatabase, k_len : float, k_ang : float, k_tors : float, k_tors_prot : float, k_tors_improper : float) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.IdealParametersDatabase,  : rosetta.core.scoring.methods.IdealParametersDatabase) -> rosetta.core.scoring.methods.IdealParametersDatabase bbdep_bond_devs(...) from builtins.PyCapsule bbdep_bond_devs(rosetta.core.scoring.methods.IdealParametersDatabase) -> bool bbdep_bond_params(...) from builtins.PyCapsule bbdep_bond_params(rosetta.core.scoring.methods.IdealParametersDatabase) -> bool init(...) from builtins.PyCapsule init(self : rosetta.core.scoring.methods.IdealParametersDatabase, k_len : float, k_ang : float, k_tors : float, k_tors_prot : float, k_tors_improper : float) -> NoneType lookup_angle(...) from builtins.PyCapsule lookup_angle(self : rosetta.core.scoring.methods.IdealParametersDatabase, rsd_type : rosetta.core.chemical.ResidueType, pre_proline : bool, atm1_name : str, atm2_name : str, atm3_name : str, atm1idx : int, atm2idx : int, atm3idx : int) -> rosetta.core.scoring.methods.CartBondedParameters lookup_angle_legacy(...) from builtins.PyCapsule lookup_angle_legacy(self : rosetta.core.scoring.methods.IdealParametersDatabase, pose : rosetta.core.pose.Pose, res : rosetta.core.conformation.Residue, atm1 : int, atm2 : int, atm3 : int, Ktheta : float, d0 : float) -> NoneType lookup_length(...) from builtins.PyCapsule lookup_length(self : rosetta.core.scoring.methods.IdealParametersDatabase, rsd_type : rosetta.core.chemical.ResidueType, pre_proline : bool, atm1_name : str, atm2_name : str, atm1idx : int, atm2idx : int) -> rosetta.core.scoring.methods.CartBondedParameters lookup_length_legacy(...) from builtins.PyCapsule lookup_length_legacy(self : rosetta.core.scoring.methods.IdealParametersDatabase, pose : rosetta.core.pose.Pose, res : rosetta.core.conformation.Residue, atm1 : int, atm2 : int, Kd : float, d0 : float) -> NoneType lookup_torsion(...) from builtins.PyCapsule lookup_torsion(self : rosetta.core.scoring.methods.IdealParametersDatabase, rsd_type : rosetta.core.chemical.ResidueType, atm1_name : str, atm2_name : str, atm3_name : str, atm4_name : str) -> rosetta.core.scoring.methods.CartBondedParameters lookup_torsion_legacy(...) from builtins.PyCapsule lookup_torsion_legacy(self : rosetta.core.scoring.methods.IdealParametersDatabase, restype : rosetta.core.chemical.ResidueType, atm1 : int, atm2 : int, atm3 : int, atm4 : int, Kphi : float, phi0 : float, phi_step : float) -> NoneType parameters_for_restype(...) from builtins.PyCapsule parameters_for_restype(self : rosetta.core.scoring.methods.IdealParametersDatabase, restype : rosetta.core.chemical.ResidueType, prepro : bool) -> rosetta.core.scoring.methods.ResidueCartBondedParameters   Return a list of all the bond lengths, bond angles, and bond torsions  for a single residue type.  This list is constructed lazily as required.  (This may cause thread safety issues!).   class IntermolEnergy(WholeStructureEnergy)       Method resolution order: IntermolEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.IntermolEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.IntermolEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   ////////////////////////////// finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.IntermolEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.IntermolEnergy,  : rosetta.utility.vector1_bool) -> NoneType Methods inherited from WholeStructureEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WholeStructureEnergy,  : rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.WholeStructureEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class IntermolEnergyCreator(EnergyMethodCreator)       Method resolution order: IntermolEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.IntermolEnergyCreator,  : rosetta.core.scoring.methods.IntermolEnergyCreator) -> rosetta.core.scoring.methods.IntermolEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.IntermolEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new IntermolEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.IntermolEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class LK_PolarNonPolarEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: LK_PolarNonPolarEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, etable_in : rosetta.core.scoring.etable.Etable, analytic_etable_evaluation : bool) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.LK_PolarNonPolarEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.LK_PolarNonPolarEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.LK_PolarNonPolarEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, weights : rosetta.core.scoring.EMapVector) -> bool defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   called during gradient-based minimization inside dfunc           F1 and F2 are not zeroed -- contributions from this atom are         just summed in eval_atom_derivative_intra_RNA(...) from builtins.PyCapsule eval_atom_derivative_intra_RNA(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType get_count_pair_function(...) from builtins.PyCapsule get_count_pair_function(*args, **kwargs) Overloaded function.   1. get_count_pair_function(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, res1 : int, res2 : int, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   2. get_count_pair_function(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue) -> rosetta.core.scoring.etable.count_pair.CountPairFunction get_intrares_countpair(...) from builtins.PyCapsule get_intrares_countpair(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, rsd1 : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, pose : rosetta.core.pose.Pose, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase) -> NoneType setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, pair_data : rosetta.core.scoring.ResPairMinimizationData) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.LK_PolarNonPolarEnergy) -> bool Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class LK_PolarNonPolarEnergyCreator(EnergyMethodCreator)       Method resolution order: LK_PolarNonPolarEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergyCreator,  : rosetta.core.scoring.methods.LK_PolarNonPolarEnergyCreator) -> rosetta.core.scoring.methods.LK_PolarNonPolarEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.LK_PolarNonPolarEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new LK_PolarNonPolarEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.LK_PolarNonPolarEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class LK_hack(ContextIndependentTwoBodyEnergy)       Method resolution order: LK_hack ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, etable_in : rosetta.core.scoring.etable.Etable) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.LK_hack) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.LK_hack) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.LK_hack) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.LK_hack,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.LK_hack, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   called during gradient-based minimization inside dfunc           F1 and F2 are not zeroed -- contributions from this atom are         just summed in eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.LK_hack,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.LK_hack, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.LK_hack, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.LK_hack, pose : rosetta.core.pose.Pose, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class LK_hackCreator(EnergyMethodCreator)       Method resolution order: LK_hackCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.LK_hackCreator,  : rosetta.core.scoring.methods.LK_hackCreator) -> rosetta.core.scoring.methods.LK_hackCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.LK_hackCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new LK_hack score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.LK_hackCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class LinearChainbreakEnergy(WholeStructureEnergy)     LinearChainbreakEnergy class iterates across all residues in finalize() and determines the penalty between residues i and i+1 by how much their psueduo atoms do not align.     Calculates both linear_chainbreak and overlap_chainbreak terms.  linear_chainbreak measures 3 distances (cutpoint variants must be added to pose):   1) virt CA res1 -> CA      res2   2) virt C    res1 -> C        res2   3)         N   res1 -> virt N res2    score = 1 + 2+ 3 /3    For ideal poses, this score should be very close to 0.  Real PDBs, however have bond length and angle   deviations that will cause this score to be fairly high.     See Also: protocols/forge/chainbreak_eval.hh     Method resolution order: LinearChainbreakEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, allowable_sequence_sep : int) -> NoneType   3. __init__(handle, rosetta.core.scoring.methods.LinearChainbreakEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.LinearChainbreakEnergy,  : rosetta.core.scoring.methods.LinearChainbreakEnergy) -> rosetta.core.scoring.methods.LinearChainbreakEnergy   The auto-generated operator=() method does not properly handle pointer types. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.LinearChainbreakEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.LinearChainbreakEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   called during gradient-based minimization inside dfunc           F1 and F2 are not zeroed -- contributions from this atom are         just summed in finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.LinearChainbreakEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   called at the end of energy evaluation indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.LinearChainbreakEnergy,  : rosetta.utility.vector1_bool) -> NoneType Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class LinearChainbreakEnergyCreator(EnergyMethodCreator)       Method resolution order: LinearChainbreakEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.LinearChainbreakEnergyCreator,  : rosetta.core.scoring.methods.LinearChainbreakEnergyCreator) -> rosetta.core.scoring.methods.LinearChainbreakEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.LinearChainbreakEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new LinearChainbreakEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.LinearChainbreakEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class LongRangeEnergyType(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.scoring.methods.LongRangeEnergyType, rosetta.core.scoring.methods.LongRangeEnergyType) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.scoring.methods.LongRangeEnergyType) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.methods.LongRangeEnergyType, int) -> NoneType   2. __init__(rosetta.core.scoring.methods.LongRangeEnergyType, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.scoring.methods.LongRangeEnergyType) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.scoring.methods.LongRangeEnergyType, rosetta.core.scoring.methods.LongRangeEnergyType) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.scoring.methods.LongRangeEnergyType) -> str Data and other attributes defined here: DFIRE = LongRangeEnergyType.DFIRE PB_elec_lr = LongRangeEnergyType.PB_elec_lr cart_bonded_lr = LongRangeEnergyType.cart_bonded_lr centroid_disulfide_energy = LongRangeEnergyType.n_long_range_types constraints_lr = LongRangeEnergyType.constraints_lr disulfide_matching_energy = LongRangeEnergyType.disulfide_matching_energy elec_dens_allatom_cen_energy = LongRangeEnergyType.elec_dens_allatom_cen_energy elec_dens_atomwise_energy = LongRangeEnergyType.elec_dens_atomwise_energy elec_dens_cen_energy = LongRangeEnergyType.elec_dens_cen_energy elec_dens_energy = LongRangeEnergyType.elec_dens_energy elec_dens_fast_energy = LongRangeEnergyType.elec_dens_fast_energy fa_disulfide_energy = LongRangeEnergyType.fa_disulfide_energy gen_born_lr = LongRangeEnergyType.gen_born_lr multipole_elec_lr = LongRangeEnergyType.multipole_elec_lr n_long_range_types = LongRangeEnergyType.n_long_range_types patterson_corr_energy = LongRangeEnergyType.patterson_corr_energy rama2b_lr = LongRangeEnergyType.rama2b_lr ramaprepro_lr = LongRangeEnergyType.ramaprepro_lr rna_suite_lr = LongRangeEnergyType.rna_suite_lr sasa_lr = LongRangeEnergyType.sasa_lr sym_bonus_lr = LongRangeEnergyType.sym_bonus_lr vdw_tinker_lr = LongRangeEnergyType.vdw_tinker_lr   class LongRangeTwoBodyEnergy(TwoBodyEnergy)       Method resolution order: LongRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.LongRangeTwoBodyEnergy, creator : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.LongRangeTwoBodyEnergy, rosetta.core.scoring.methods.LongRangeTwoBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.LongRangeTwoBodyEnergy,  : rosetta.core.scoring.methods.LongRangeTwoBodyEnergy) -> rosetta.core.scoring.methods.LongRangeTwoBodyEnergy defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.methods.LongRangeTwoBodyEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.methods.LongRangeTwoBodyEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, weights : rosetta.core.scoring.EMapVector) -> bool   Two body energies are able to define intra-residue energies, and to do so  only in the presence of certain non-zero weights.  The ScoreFunction will hand over its  weight set as it asks whether the energy method defines an intraresidue energy or not.    For example, the Etable method defines intra-residue energies only when one or more  of the fa_intra_{atr,rep,sol} weights are non-zero. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between a given residue pair  accumulating the unweighted energies in an EnergyMap residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethodType   Return one of the 7 kinds of energy methods that exist:  e.g. context-dependent-one-body vs whole-structure. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MMBondAngleEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: MMBondAngleEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.MMBondAngleEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.MMBondAngleEnergy) -> float   MMBondAngleEnergy does not have an atomic interation threshold clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MMBondAngleEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.MMBondAngleEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.MMBondAngleEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.MMBondAngleEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MMBondAngleEnergy,  : rosetta.utility.vector1_bool) -> NoneType   MMBondAngleEnergy is context independent; indicates that no  context graphs are required residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.MMBondAngleEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType residue_type_param_set(...) from builtins.PyCapsule residue_type_param_set(*args, **kwargs) Overloaded function.   1. residue_type_param_set(self : rosetta.core.scoring.methods.MMBondAngleEnergy, param_set : rosetta.core.scoring.mm.MMBondAngleResidueTypeParamSet) -> NoneType   set underlying MMBondAngleResidueTypeParamSet   2. residue_type_param_set(rosetta.core.scoring.methods.MMBondAngleEnergy) -> rosetta.core.scoring.mm.MMBondAngleResidueTypeParamSet   get underlying MMBondAngleResidueTypeParamSet   3. residue_type_param_set(rosetta.core.scoring.methods.MMBondAngleEnergy) -> rosetta.core.scoring.mm.MMBondAngleResidueTypeParamSet   get underlying MMBondAngleResidueTypeParamSet setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.MMBondAngleEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.MMBondAngleEnergy, pose : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.MMBondAngleEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MMBondAngleEnergyCreator(EnergyMethodCreator)       Method resolution order: MMBondAngleEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MMBondAngleEnergyCreator,  : rosetta.core.scoring.methods.MMBondAngleEnergyCreator) -> rosetta.core.scoring.methods.MMBondAngleEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MMBondAngleEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MMBondAngleEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MMBondAngleEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MMBondLengthEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: MMBondLengthEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.MMBondLengthEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.MMBondLengthEnergy) -> float   MMBondLengthEnergy does not have an atomic interation threshold clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MMBondLengthEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.MMBondLengthEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.MMBondLengthEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.MMBondLengthEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MMBondLengthEnergy,  : rosetta.utility.vector1_bool) -> NoneType   MMBondLengthEnergy is context independent; indicates that no  context graphs are required residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.MMBondLengthEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.MMBondLengthEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.MMBondLengthEnergy, pose : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.MMBondLengthEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MMBondLengthEnergyCreator(EnergyMethodCreator)       Method resolution order: MMBondLengthEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MMBondLengthEnergyCreator,  : rosetta.core.scoring.methods.MMBondLengthEnergyCreator) -> rosetta.core.scoring.methods.MMBondLengthEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MMBondLengthEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MMBondLengthEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MMBondLengthEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MMLJEnergyInter(ContextIndependentTwoBodyEnergy)       Method resolution order: MMLJEnergyInter ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.MMLJEnergyInter) -> float   MMLJEnergyInter does not have an atomic interation threshold bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.MMLJEnergyInter, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.MMLJEnergyInter, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MMLJEnergyInter) -> rosetta.core.scoring.methods.EnergyMethod   clone create_rotamer_trie(...) from builtins.PyCapsule create_rotamer_trie(*args, **kwargs) Overloaded function.   1. create_rotamer_trie(self : rosetta.core.scoring.methods.MMLJEnergyInter, rotset : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose) -> rosetta.core.scoring.trie.RotamerTrieBase   2. create_rotamer_trie(self : rosetta.core.scoring.methods.MMLJEnergyInter, res : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose) -> rosetta.core.scoring.trie.RotamerTrieBase defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.MMLJEnergyInter,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.MMLJEnergyInter, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose,  : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.MMLJEnergyInter, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.MMLJEnergyInter, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.MMLJEnergyInter, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType get_count_pair_function(...) from builtins.PyCapsule get_count_pair_function(*args, **kwargs) Overloaded function.   1. get_count_pair_function(self : rosetta.core.scoring.methods.MMLJEnergyInter, res1 : int, res2 : int, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   required for neighbor list and to be more lke the ETable   2. get_count_pair_function(self : rosetta.core.scoring.methods.MMLJEnergyInter, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   required for neighbor list and to be more lke the ETable get_count_pair_function_trie(...) from builtins.PyCapsule get_count_pair_function_trie(*args, **kwargs) Overloaded function.   1. get_count_pair_function_trie(self : rosetta.core.scoring.methods.MMLJEnergyInter, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, trie1 : rosetta.core.scoring.trie.RotamerTrieBase, trie2 : rosetta.core.scoring.trie.RotamerTrieBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.trie.TrieCountPairBase   2. get_count_pair_function_trie(self : rosetta.core.scoring.methods.MMLJEnergyInter, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.trie.TrieCountPairBase get_intrares_countpair(...) from builtins.PyCapsule get_intrares_countpair(self : rosetta.core.scoring.methods.MMLJEnergyInter, res : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   required for neighbor list and to be more lke the ETable heavyatom_heavyatom_energy(...) from builtins.PyCapsule heavyatom_heavyatom_energy(self : rosetta.core.scoring.methods.MMLJEnergyInter, at1 : rosetta.core.scoring.mm.mmtrie.MMEnergyTableAtom, at2 : rosetta.core.scoring.mm.mmtrie.MMEnergyTableAtom, d2 : float, path_dist : int) -> float heavyatom_hydrogenatom_energy(...) from builtins.PyCapsule heavyatom_hydrogenatom_energy(self : rosetta.core.scoring.methods.MMLJEnergyInter, at1 : rosetta.core.scoring.mm.mmtrie.MMEnergyTableAtom, at2 : rosetta.core.scoring.mm.mmtrie.MMEnergyTableAtom, path_dist : int) -> float hydrogen_interaction_cutoff(...) from builtins.PyCapsule hydrogen_interaction_cutoff(rosetta.core.scoring.methods.MMLJEnergyInter) -> float hydrogen_interaction_cutoff2(...) from builtins.PyCapsule hydrogen_interaction_cutoff2(rosetta.core.scoring.methods.MMLJEnergyInter) -> float   How close do two heavy atoms have to be such that their hydrogen atoms might interact?   max heavy-to-hydrogen distance ( MAGIC NUMBER!!!! FIX IT ) + atom-pair interaction distance. hydrogenatom_heavyatom_energy(...) from builtins.PyCapsule hydrogenatom_heavyatom_energy(self : rosetta.core.scoring.methods.MMLJEnergyInter, at1 : rosetta.core.scoring.mm.mmtrie.MMEnergyTableAtom, at2 : rosetta.core.scoring.mm.mmtrie.MMEnergyTableAtom, path_dist : int) -> float hydrogenatom_hydrogenatom_energy(...) from builtins.PyCapsule hydrogenatom_hydrogenatom_energy(self : rosetta.core.scoring.methods.MMLJEnergyInter, at1 : rosetta.core.scoring.mm.mmtrie.MMEnergyTableAtom, at2 : rosetta.core.scoring.mm.mmtrie.MMEnergyTableAtom, path_dist : int) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MMLJEnergyInter,  : rosetta.utility.vector1_bool) -> NoneType   MMLJEnergyInter is context independent; indicates that no context graphs are required prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.MMLJEnergyInter, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.MMLJEnergyInter, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.MMLJEnergyInter, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.MMLJEnergyInter, pose : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.MMLJEnergyInter, pose : rosetta.core.pose.Pose, resid : int) -> NoneType Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MMLJEnergyInterCreator(EnergyMethodCreator)       Method resolution order: MMLJEnergyInterCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MMLJEnergyInterCreator,  : rosetta.core.scoring.methods.MMLJEnergyInterCreator) -> rosetta.core.scoring.methods.MMLJEnergyInterCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MMLJEnergyInterCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MMTorsionEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MMLJEnergyInterCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MMLJEnergyIntra(ContextIndependentTwoBodyEnergy)       Method resolution order: MMLJEnergyIntra ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.MMLJEnergyIntra) -> float   MMLJEnergy does not have an atomic interation threshold clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MMLJEnergyIntra) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.MMLJEnergyIntra,  : rosetta.core.scoring.EMapVector) -> bool eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.MMLJEnergyIntra, rsd : rosetta.core.conformation.Residue, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.MMLJEnergyIntra, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.MMLJEnergyIntra, rsd : rosetta.core.conformation.Residue, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType get_count_pair_function(...) from builtins.PyCapsule get_count_pair_function(*args, **kwargs) Overloaded function.   1. get_count_pair_function(self : rosetta.core.scoring.methods.MMLJEnergyIntra, res1 : int, res2 : int, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   required for neighbor list and to be more lke the ETable   2. get_count_pair_function(self : rosetta.core.scoring.methods.MMLJEnergyIntra, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   required for neighbor list and to be more lke the ETable get_intrares_countpair(...) from builtins.PyCapsule get_intrares_countpair(self : rosetta.core.scoring.methods.MMLJEnergyIntra, res : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   required for neighbor list and to be more lke the ETable indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MMLJEnergyIntra,  : rosetta.utility.vector1_bool) -> NoneType   MMLJEnergy is context independent; indicates that no context graphs are required minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.MMLJEnergyIntra,  : rosetta.core.pose.Pose) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.MMLJEnergyIntra, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.MMLJEnergyIntra, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.MMLJEnergyIntra) -> bool Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MMLJEnergyIntraCreator(EnergyMethodCreator)       Method resolution order: MMLJEnergyIntraCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MMLJEnergyIntraCreator,  : rosetta.core.scoring.methods.MMLJEnergyIntraCreator) -> rosetta.core.scoring.methods.MMLJEnergyIntraCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MMLJEnergyIntraCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MMTorsionEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MMLJEnergyIntraCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MMTorsionEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: MMTorsionEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.MMTorsionEnergy) -> float   MMTorsionEnergy does not have an atomic interation threshold clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MMTorsionEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.MMTorsionEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.MMTorsionEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   evaluate xyz derivatives (and not DOF derivatives)  for a particular atom. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.MMTorsionEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.MMTorsionEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MMTorsionEnergy,  : rosetta.utility.vector1_bool) -> NoneType   MMTorsionEnergy is context independent; indicates that no  context graphs are required minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.MMTorsionEnergy,  : rosetta.core.pose.Pose) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.MMTorsionEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.MMTorsionEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   setup for derivatives setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.MMTorsionEnergy, pose : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   setup for packing setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.MMTorsionEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   setup for scoring Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MMTorsionEnergyCreator(EnergyMethodCreator)       Method resolution order: MMTorsionEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MMTorsionEnergyCreator,  : rosetta.core.scoring.methods.MMTorsionEnergyCreator) -> rosetta.core.scoring.methods.MMTorsionEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MMTorsionEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MMTorsionEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MMTorsionEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MembraneCbetaEnergy(ContextDependentOneBodyEnergy)       Method resolution order: MembraneCbetaEnergy ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: MembraneTopology_from_pose(...) from builtins.PyCapsule MembraneTopology_from_pose(self : rosetta.core.scoring.methods.MembraneCbetaEnergy, pose : rosetta.core.pose.Pose) -> rosetta.core.scoring.MembraneTopology __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MembraneCbetaEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.MembraneCbetaEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MembraneCbetaEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.MembraneCbetaEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.MembraneCbetaEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextDependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MembraneCbetaEnergyCreator(EnergyMethodCreator)       Method resolution order: MembraneCbetaEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MembraneCbetaEnergyCreator,  : rosetta.core.scoring.methods.MembraneCbetaEnergyCreator) -> rosetta.core.scoring.methods.MembraneCbetaEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MembraneCbetaEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MembraneCbetaEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MembraneCbetaEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MembraneCenPairEnergy(ContextDependentTwoBodyEnergy)       Method resolution order: MembraneCenPairEnergy ContextDependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: MembraneTopology_from_pose(...) from builtins.PyCapsule MembraneTopology_from_pose(self : rosetta.core.scoring.methods.MembraneCenPairEnergy, pose : rosetta.core.pose.Pose) -> rosetta.core.scoring.MembraneTopology __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.MembraneCenPairEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MembraneCenPairEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.MembraneCenPairEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.MembraneCenPairEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.MembraneCenPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MembraneCenPairEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.MembraneCenPairEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.MembraneCenPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextDependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MembraneCenPairEnergyCreator(EnergyMethodCreator)       Method resolution order: MembraneCenPairEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MembraneCenPairEnergyCreator,  : rosetta.core.scoring.methods.MembraneCenPairEnergyCreator) -> rosetta.core.scoring.methods.MembraneCenPairEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MembraneCenPairEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MembraneCenPairEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MembraneCenPairEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MembraneEnvEnergy(ContextDependentOneBodyEnergy)       Method resolution order: MembraneEnvEnergy ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: MembraneTopology_from_pose(...) from builtins.PyCapsule MembraneTopology_from_pose(self : rosetta.core.scoring.methods.MembraneEnvEnergy, pose : rosetta.core.pose.Pose) -> rosetta.core.scoring.MembraneTopology __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MembraneEnvEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.MembraneEnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MembraneEnvEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.MembraneEnvEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.MembraneEnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.MembraneEnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextDependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MembraneEnvEnergyCreator(EnergyMethodCreator)       Method resolution order: MembraneEnvEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MembraneEnvEnergyCreator,  : rosetta.core.scoring.methods.MembraneEnvEnergyCreator) -> rosetta.core.scoring.methods.MembraneEnvEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MembraneEnvEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MembraneEnvEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MembraneEnvEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MembraneEnvPenalties(WholeStructureEnergy)       Method resolution order: MembraneEnvPenalties WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MembraneEnvPenalties) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.MembraneEnvPenalties, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MembraneEnvPenalties,  : rosetta.utility.vector1_bool) -> NoneType Methods inherited from WholeStructureEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WholeStructureEnergy,  : rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.WholeStructureEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MembraneEnvPenaltiesCreator(EnergyMethodCreator)       Method resolution order: MembraneEnvPenaltiesCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MembraneEnvPenaltiesCreator,  : rosetta.core.scoring.methods.MembraneEnvPenaltiesCreator) -> rosetta.core.scoring.methods.MembraneEnvPenaltiesCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MembraneEnvPenaltiesCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MembraneEnvPenalties score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MembraneEnvPenaltiesCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MembraneEnvSmoothEnergy(ContextDependentOneBodyEnergy)       Method resolution order: MembraneEnvSmoothEnergy ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.MembraneEnvSmoothEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MembraneEnvSmoothEnergy,  : rosetta.core.scoring.methods.MembraneEnvSmoothEnergy) -> rosetta.core.scoring.methods.MembraneEnvSmoothEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.MembraneEnvSmoothEnergy) -> float   unused by the MembraneEnvSmoothEnergy class, returns 0 clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MembraneEnvSmoothEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.MembraneEnvSmoothEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose,  : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   increments the F1 and F2 derivative vectors for an atom indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MembraneEnvSmoothEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Tells the scoring function to maintain the TwelveANeighborGraph residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.MembraneEnvSmoothEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.EMapVector) -> NoneType   evaluates the one-body energy for a residue setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.MembraneEnvSmoothEnergy, pose : rosetta.core.pose.Pose, sf : rosetta.core.scoring.ScoreFunction) -> NoneType   causes a neighbor graph update setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.MembraneEnvSmoothEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   computes dScore/dNumNeighbors for all residues for rapid use in later  atom derivate calculations Methods inherited from ContextDependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MembraneEnvSmoothEnergyCreator(EnergyMethodCreator)       Method resolution order: MembraneEnvSmoothEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MembraneEnvSmoothEnergyCreator,  : rosetta.core.scoring.methods.MembraneEnvSmoothEnergyCreator) -> rosetta.core.scoring.methods.MembraneEnvSmoothEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MembraneEnvSmoothEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MembraneEnvSmoothEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MembraneEnvSmoothEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MembraneLipo(WholeStructureEnergy)       Method resolution order: MembraneLipo WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MembraneLipo) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.MembraneLipo, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MembraneLipo,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.MembraneLipo, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from WholeStructureEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WholeStructureEnergy,  : rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.WholeStructureEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MembraneLipoCreator(EnergyMethodCreator)       Method resolution order: MembraneLipoCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MembraneLipoCreator,  : rosetta.core.scoring.methods.MembraneLipoCreator) -> rosetta.core.scoring.methods.MembraneLipoCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MembraneLipoCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MembraneLipo score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MembraneLipoCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MissingEnergy(WholeStructureEnergy)       Method resolution order: MissingEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MissingEnergy,  : rosetta.core.scoring.methods.MissingEnergy) -> rosetta.core.scoring.methods.MissingEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MissingEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.MissingEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   ////////////////////////////// finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.MissingEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MissingEnergy,  : rosetta.utility.vector1_bool) -> NoneType Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MissingEnergyCreator(EnergyMethodCreator)       Method resolution order: MissingEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MissingEnergyCreator,  : rosetta.core.scoring.methods.MissingEnergyCreator) -> rosetta.core.scoring.methods.MissingEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MissingEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MissingEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MissingEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class MultipoleElecEnergy(ContextIndependentLRTwoBodyEnergy)       Method resolution order: MultipoleElecEnergy ContextIndependentLRTwoBodyEnergy LongRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.MultipoleElecEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.MultipoleElecEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.MultipoleElecEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.methods.MultipoleElecEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.MultipoleElecEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.MultipoleElecEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.MultipoleElecEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.MultipoleElecEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.MultipoleElecEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.MultipoleElecEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.MultipoleElecEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.MultipoleElecEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.MultipoleElecEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.MultipoleElecEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.methods.MultipoleElecEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType packing_interaction_cutoff(...) from builtins.PyCapsule packing_interaction_cutoff(rosetta.core.scoring.methods.MultipoleElecEnergy) -> float   this is our own special function prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.MultipoleElecEnergy, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.MultipoleElecEnergy,  : rosetta.core.pose.Pose) -> bool requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.MultipoleElecEnergy,  : rosetta.core.pose.Pose) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.MultipoleElecEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.MultipoleElecEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pairdata : rosetta.core.scoring.ResPairMinimizationData,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.MultipoleElecEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.MultipoleElecEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.MultipoleElecEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase, resdata : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.MultipoleElecEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase, res1data : rosetta.core.scoring.ResSingleMinimizationData, res2data : rosetta.core.scoring.ResSingleMinimizationData, pairdata : rosetta.core.scoring.ResPairMinimizationData) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.MultipoleElecEnergy, pose : rosetta.core.pose.Pose, residues_repacking : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.MultipoleElecEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.MultipoleElecEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, resdata : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.MultipoleElecEnergy,  : rosetta.core.pose.Pose, resid : int) -> NoneType use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.MultipoleElecEnergy) -> bool use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.MultipoleElecEnergy) -> bool Methods inherited from ContextIndependentLRTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class MultipoleElecEnergyCreator(EnergyMethodCreator)       Method resolution order: MultipoleElecEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.MultipoleElecEnergyCreator,  : rosetta.core.scoring.methods.MultipoleElecEnergyCreator) -> rosetta.core.scoring.methods.MultipoleElecEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.MultipoleElecEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MultipoleElecEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.MultipoleElecEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class NMerPSSMEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: NMerPSSMEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, all_nmer_pssms_in : rosetta.utility.vector1_std_map_core_chemical_AA_utility_vector1_double_std_allocator_double_std_less_core_chemical_AA_std_allocator_std_pair_const_core_chemical_AA_utility_vector1_double_std_allocator_double_t) -> NoneType   3. __init__(handle, rosetta.core.scoring.methods.NMerPSSMEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.NMerPSSMEnergy,  : rosetta.core.scoring.methods.NMerPSSMEnergy) -> rosetta.core.scoring.methods.NMerPSSMEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.NMerPSSMEnergy) -> rosetta.core.scoring.methods.EnergyMethod eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.NMerPSSMEnergy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float gate_pssm_scores(...) from builtins.PyCapsule gate_pssm_scores(self : rosetta.core.scoring.methods.NMerPSSMEnergy,  : bool) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.NMerPSSMEnergy,  : rosetta.utility.vector1_bool) -> NoneType   DunbrackEnergy is context independent; indicates that no  context graphs are required minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.NMerPSSMEnergy,  : rosetta.core.pose.Pose) -> bool n_pssms(...) from builtins.PyCapsule n_pssms(rosetta.core.scoring.methods.NMerPSSMEnergy) -> int nmer_length(...) from builtins.PyCapsule nmer_length(self : rosetta.core.scoring.methods.NMerPSSMEnergy,  : int) -> NoneType nmer_pssm_scorecut(...) from builtins.PyCapsule nmer_pssm_scorecut(self : rosetta.core.scoring.methods.NMerPSSMEnergy,  : float) -> NoneType pssm_energy_at_frame_seqpos(...) from builtins.PyCapsule pssm_energy_at_frame_seqpos(self : rosetta.core.scoring.methods.NMerPSSMEnergy,  : int,  : rosetta.core.chemical.AA,  : int) -> float read_nmer_pssm(...) from builtins.PyCapsule read_nmer_pssm(self : rosetta.core.scoring.methods.NMerPSSMEnergy,  : str) -> NoneType read_nmer_pssm_list(...) from builtins.PyCapsule read_nmer_pssm_list(self : rosetta.core.scoring.methods.NMerPSSMEnergy,  : str) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.NMerPSSMEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class NMerPSSMEnergyCreator(EnergyMethodCreator)       Method resolution order: NMerPSSMEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.NMerPSSMEnergyCreator,  : rosetta.core.scoring.methods.NMerPSSMEnergyCreator) -> rosetta.core.scoring.methods.NMerPSSMEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.NMerPSSMEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new NMerPSSMEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.NMerPSSMEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class NMerRefEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: NMerRefEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, nmer_ref_energies_in : rosetta.std.map_std_string_double) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.NMerRefEnergy,  : rosetta.core.scoring.methods.NMerRefEnergy) -> rosetta.core.scoring.methods.NMerRefEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.NMerRefEnergy) -> rosetta.core.scoring.methods.EnergyMethod eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.NMerRefEnergy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.NMerRefEnergy,  : rosetta.utility.vector1_bool) -> NoneType   DunbrackEnergy is context independent; indicates that no  context graphs are required initialize_from_options(...) from builtins.PyCapsule initialize_from_options(rosetta.core.scoring.methods.NMerRefEnergy) -> NoneType minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.NMerRefEnergy,  : rosetta.core.pose.Pose) -> bool nmer_length(...) from builtins.PyCapsule nmer_length(self : rosetta.core.scoring.methods.NMerRefEnergy, nmer_length : int) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.NMerRefEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class NMerRefEnergyCreator(EnergyMethodCreator)       Method resolution order: NMerRefEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.NMerRefEnergyCreator,  : rosetta.core.scoring.methods.NMerRefEnergyCreator) -> rosetta.core.scoring.methods.NMerRefEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.NMerRefEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new NMerRefEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.NMerRefEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class NMerSVMEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: NMerSVMEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, svm_fnames : rosetta.utility.vector1_std_string) -> NoneType   3. __init__(handle, rosetta.core.scoring.methods.NMerSVMEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_encoded_termini(...) from builtins.PyCapsule add_encoded_termini(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : str,  : int,  : rosetta.utility.vector1_double) -> NoneType add_pssm_features(...) from builtins.PyCapsule add_pssm_features(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : str,  : int,  : rosetta.utility.vector1_double) -> NoneType assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : rosetta.core.scoring.methods.NMerSVMEnergy) -> rosetta.core.scoring.methods.NMerSVMEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.NMerSVMEnergy) -> rosetta.core.scoring.methods.EnergyMethod encode_aa_string(...) from builtins.PyCapsule encode_aa_string(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : str) -> rosetta.utility.vector1_double encode_nmer(...) from builtins.PyCapsule encode_nmer(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : str,  : int,  : int) -> rosetta.utility.vector1_double encode_wtd_avg_aa_string(...) from builtins.PyCapsule encode_wtd_avg_aa_string(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : str,  : rosetta.utility.vector1_double) -> rosetta.utility.vector1_double eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.NMerSVMEnergy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float gate_svm_scores(...) from builtins.PyCapsule gate_svm_scores(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : bool) -> NoneType get_residue_energy_by_svm(...) from builtins.PyCapsule get_residue_energy_by_svm(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : rosetta.core.pose.Pose,  : int,  : float,  : rosetta.utility.vector1_double) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : rosetta.utility.vector1_bool) -> NoneType   context independent; indicates that no  context graphs are required minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : rosetta.core.pose.Pose) -> bool n_svms(...) from builtins.PyCapsule n_svms(rosetta.core.scoring.methods.NMerSVMEnergy) -> int nmer_length(...) from builtins.PyCapsule nmer_length(*args, **kwargs) Overloaded function.   1. nmer_length(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : int) -> NoneType   2. nmer_length(rosetta.core.scoring.methods.NMerSVMEnergy) -> int nmer_svm_scorecut(...) from builtins.PyCapsule nmer_svm_scorecut(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : float) -> NoneType read_aa_encoding_matrix(...) from builtins.PyCapsule read_aa_encoding_matrix(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : str) -> NoneType read_nmer_svm(...) from builtins.PyCapsule read_nmer_svm(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : str) -> NoneType read_nmer_svm_list(...) from builtins.PyCapsule read_nmer_svm_list(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : str) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.NMerSVMEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// term_length(...) from builtins.PyCapsule term_length(*args, **kwargs) Overloaded function.   1. term_length(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : int) -> NoneType   2. term_length(rosetta.core.scoring.methods.NMerSVMEnergy) -> int use_pssm_features(...) from builtins.PyCapsule use_pssm_features(self : rosetta.core.scoring.methods.NMerSVMEnergy,  : bool) -> NoneType Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class NMerSVMEnergyCreator(EnergyMethodCreator)       Method resolution order: NMerSVMEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.NMerSVMEnergyCreator,  : rosetta.core.scoring.methods.NMerSVMEnergyCreator) -> rosetta.core.scoring.methods.NMerSVMEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.NMerSVMEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new NMerSVMEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.NMerSVMEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class NeighborListData(rosetta.basic.datacache.CacheableData)       Method resolution order: NeighborListData rosetta.basic.datacache.CacheableData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, nblist : rosetta.core.scoring.NeighborList) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.NeighborListData) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.NeighborListData,  : rosetta.core.scoring.methods.NeighborListData) -> rosetta.core.scoring.methods.NeighborListData clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.NeighborListData) -> rosetta.basic.datacache.CacheableData nblist(...) from builtins.PyCapsule nblist(*args, **kwargs) Overloaded function.   1. nblist(rosetta.core.scoring.methods.NeighborListData) -> rosetta.core.scoring.NeighborList   2. nblist(self : rosetta.core.scoring.methods.NeighborListData, nblist : rosetta.core.scoring.NeighborList) -> NoneType Methods inherited from rosetta.basic.datacache.CacheableData: get_self_ptr(...) from builtins.PyCapsule get_self_ptr(*args, **kwargs) Overloaded function.   1. get_self_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.basic.datacache.CacheableData   self pointers   2. get_self_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.basic.datacache.CacheableData get_self_weak_ptr(...) from builtins.PyCapsule get_self_weak_ptr(*args, **kwargs) Overloaded function.   1. get_self_weak_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.std.weak_ptr_const_basic_datacache_CacheableData_t   2. get_self_weak_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.std.weak_ptr_basic_datacache_CacheableData_t   class OmegaTetherEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: OmegaTetherEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.OmegaTetherEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OmegaTetherEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OmegaTetherEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.OmegaTetherEnergy,  : rosetta.utility.vector1_bool) -> NoneType   OmegaTether Energy is context independent and thus indicates that no context graphs need to  be maintained by class Energies minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.OmegaTetherEnergy,  : rosetta.core.pose.Pose) -> bool old_eval_dof_derivative(...) from builtins.PyCapsule old_eval_dof_derivative(self : rosetta.core.scoring.methods.OmegaTetherEnergy,  : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.OmegaTetherEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class OmegaTetherEnergyCreator(EnergyMethodCreator)       Method resolution order: OmegaTetherEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.OmegaTetherEnergyCreator,  : rosetta.core.scoring.methods.OmegaTetherEnergyCreator) -> rosetta.core.scoring.methods.OmegaTetherEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.OmegaTetherEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new OmegaTetherEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.OmegaTetherEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class OneBodyEnergy(EnergyMethod)       Method resolution order: OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.OneBodyEnergy,  : core::scoring::methods::EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.OneBodyEnergy, rosetta.core.scoring.methods.OneBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.scoring.methods.OneBodyEnergy) -> rosetta.core.scoring.methods.OneBodyEnergy defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and increment those energies in the input Emap (do not overwrite them). residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethodType   Return one of the 7 kinds of energy methods that exist:  e.g. context-dependent-one-body vs whole-structure. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class OtherPoseEnergy(WholeStructureEnergy)       Method resolution order: OtherPoseEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.OtherPoseEnergy,  : rosetta.core.scoring.methods.OtherPoseEnergy) -> rosetta.core.scoring.methods.OtherPoseEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.OtherPoseEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.OtherPoseEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.OtherPoseEnergy,  : rosetta.utility.vector1_bool) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.OtherPoseEnergy) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class OtherPoseEnergyCreator(EnergyMethodCreator)       Method resolution order: OtherPoseEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.OtherPoseEnergyCreator,  : rosetta.core.scoring.methods.OtherPoseEnergyCreator) -> rosetta.core.scoring.methods.OtherPoseEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.OtherPoseEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new OtherPoseEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.OtherPoseEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class PBLifetimeCache(rosetta.basic.datacache.CacheableData)       Method resolution order: PBLifetimeCache rosetta.basic.datacache.CacheableData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.PBLifetimeCache) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.PBLifetimeCache,  : rosetta.core.scoring.methods.PBLifetimeCache) -> rosetta.core.scoring.methods.PBLifetimeCache clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.PBLifetimeCache) -> rosetta.basic.datacache.CacheableData get_charged_residues_map(...) from builtins.PyCapsule get_charged_residues_map(rosetta.core.scoring.methods.PBLifetimeCache) -> rosetta.std.map_std_string_bool get_energy_state(...) from builtins.PyCapsule get_energy_state(rosetta.core.scoring.methods.PBLifetimeCache) -> str get_pbp(...) from builtins.PyCapsule get_pbp(self : rosetta.core.scoring.methods.PBLifetimeCache, energy_state : str) -> rosetta.core.scoring.PoissonBoltzmannPotential get_pose(...) from builtins.PyCapsule get_pose(self : rosetta.core.scoring.methods.PBLifetimeCache, energy_state : str) -> rosetta.core.pose.Pose has_cache(...) from builtins.PyCapsule has_cache(self : rosetta.core.scoring.methods.PBLifetimeCache, energy_state : str) -> bool set_charged_residues_map(...) from builtins.PyCapsule set_charged_residues_map(self : rosetta.core.scoring.methods.PBLifetimeCache, charged_residues_map : rosetta.std.map_std_string_bool) -> NoneType set_conformational_data(...) from builtins.PyCapsule set_conformational_data(self : rosetta.core.scoring.methods.PBLifetimeCache, energy_state : str, pose : rosetta.core.pose.Pose, pb : rosetta.core.scoring.PoissonBoltzmannPotential) -> NoneType set_energy_state(...) from builtins.PyCapsule set_energy_state(self : rosetta.core.scoring.methods.PBLifetimeCache, energy_state : str) -> NoneType Methods inherited from rosetta.basic.datacache.CacheableData: get_self_ptr(...) from builtins.PyCapsule get_self_ptr(*args, **kwargs) Overloaded function.   1. get_self_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.basic.datacache.CacheableData   self pointers   2. get_self_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.basic.datacache.CacheableData get_self_weak_ptr(...) from builtins.PyCapsule get_self_weak_ptr(*args, **kwargs) Overloaded function.   1. get_self_weak_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.std.weak_ptr_const_basic_datacache_CacheableData_t   2. get_self_weak_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.std.weak_ptr_basic_datacache_CacheableData_t   class P_AA_Energy(ContextIndependentOneBodyEnergy)       Method resolution order: P_AA_Energy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.P_AA_Energy) -> rosetta.core.scoring.methods.EnergyMethod eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.P_AA_Energy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.P_AA_Energy,  : rosetta.utility.vector1_bool) -> NoneType   P_AA_Energy is context independent; indicates that no context graphs are required residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.P_AA_Energy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType Methods inherited from ContextIndependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class P_AA_EnergyCreator(EnergyMethodCreator)       Method resolution order: P_AA_EnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.P_AA_EnergyCreator,  : rosetta.core.scoring.methods.P_AA_EnergyCreator) -> rosetta.core.scoring.methods.P_AA_EnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.P_AA_EnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new P_AA_Energy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.P_AA_EnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class P_AA_pp_Energy(ContextIndependentOneBodyEnergy)       Method resolution order: P_AA_pp_Energy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.P_AA_pp_Energy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.P_AA_pp_Energy, p : rosetta.core.pose.Pose) -> bool   The P_AA_pp energy function describes derivatives wrt phi and psi. eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.P_AA_pp_Energy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   APL Deprecated 6.29.2010 eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.P_AA_pp_Energy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the P_AA_pp DOF derivative for a particular residue. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.P_AA_pp_Energy,  : rosetta.utility.vector1_bool) -> NoneType   P_AA_pp_Energy is context independent; indicates that no  context graphs are required minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.P_AA_pp_Energy,  : rosetta.core.pose.Pose) -> bool residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.P_AA_pp_Energy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class P_AA_pp_EnergyCreator(EnergyMethodCreator)       Method resolution order: P_AA_pp_EnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.P_AA_pp_EnergyCreator,  : rosetta.core.scoring.methods.P_AA_pp_EnergyCreator) -> rosetta.core.scoring.methods.P_AA_pp_EnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.P_AA_pp_EnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new P_AA_pp_Energy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.P_AA_pp_EnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class P_AA_ss_Energy(ContextIndependentOneBodyEnergy)       Method resolution order: P_AA_ss_Energy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.P_AA_ss_Energy) -> rosetta.core.scoring.methods.EnergyMethod eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.P_AA_ss_Energy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.P_AA_ss_Energy,  : rosetta.utility.vector1_bool) -> NoneType   P_AA_ss_Energy is context independent; indicates that no context graphs are required residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.P_AA_ss_Energy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.P_AA_ss_Energy,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.P_AA_ss_Energy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextIndependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class P_AA_ss_EnergyCreator(EnergyMethodCreator)       Method resolution order: P_AA_ss_EnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.P_AA_ss_EnergyCreator,  : rosetta.core.scoring.methods.P_AA_ss_EnergyCreator) -> rosetta.core.scoring.methods.P_AA_ss_EnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.P_AA_ss_EnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new P_AA_ss_Energy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.P_AA_ss_EnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class PackStatEnergy(WholeStructureEnergy)       Method resolution order: PackStatEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.PackStatEnergy,  : rosetta.core.scoring.methods.PackStatEnergy) -> rosetta.core.scoring.methods.PackStatEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.PackStatEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.PackStatEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.PackStatEnergy,  : rosetta.utility.vector1_bool) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.PackStatEnergy) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class PackStatEnergyCreator(EnergyMethodCreator)       Method resolution order: PackStatEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.PackStatEnergyCreator,  : rosetta.core.scoring.methods.PackStatEnergyCreator) -> rosetta.core.scoring.methods.PackStatEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.PackStatEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new PackStatEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.PackStatEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class PairEnergy(ContextDependentTwoBodyEnergy)       Method resolution order: PairEnergy ContextDependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.PairEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.PairEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.PairEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.PairEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.PairEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.PairEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.PairEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.PairEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.PairEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.PairEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType interaction_cutoff(...) from builtins.PyCapsule interaction_cutoff(rosetta.core.scoring.methods.PairEnergy) -> float   non-virtual accessor for speed minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.PairEnergy,  : rosetta.core.pose.Pose) -> bool prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.PairEnergy, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.PairEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.PairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.PairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.PairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.PairEnergy,  : rosetta.core.pose.Pose, resid : int) -> NoneType Methods inherited from ContextDependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class PairEnergyCreator(EnergyMethodCreator)       Method resolution order: PairEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.PairEnergyCreator,  : rosetta.core.scoring.methods.PairEnergyCreator) -> rosetta.core.scoring.methods.PairEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.PairEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new PairEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.PairEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class PeptideBondEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: PeptideBondEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.PeptideBondEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.PeptideBondEnergy,  : rosetta.core.scoring.methods.PeptideBondEnergy) -> rosetta.core.scoring.methods.PeptideBondEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.PeptideBondEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.PeptideBondEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.PeptideBondEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.PeptideBondEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   called during gradient-based minimization inside dfunc           F1 and F2 are not zeroed -- contributions from this atom are         just summed in eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.PeptideBondEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.PeptideBondEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.PeptideBondEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.PeptideBondEnergy) -> int Methods inherited from ContextIndependentTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class PeptideBondEnergyCreator(EnergyMethodCreator)       Method resolution order: PeptideBondEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.PeptideBondEnergyCreator,  : rosetta.core.scoring.methods.PeptideBondEnergyCreator) -> rosetta.core.scoring.methods.PeptideBondEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.PeptideBondEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new PeptideBondEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.PeptideBondEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class PoissonBoltzmannEnergy(ContextIndependentLRTwoBodyEnergy)       Method resolution order: PoissonBoltzmannEnergy ContextIndependentLRTwoBodyEnergy LongRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.PoissonBoltzmannEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergy,  : rosetta.core.scoring.methods.PoissonBoltzmannEnergy) -> rosetta.core.scoring.methods.PoissonBoltzmannEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.PoissonBoltzmannEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergy,  : rosetta.utility.vector1_bool) -> NoneType   PB Energy is context independent and thus indicates that no context graphs need to  be maintained by class Energies long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.methods.PoissonBoltzmannEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType   ////////////////////////////////////////////////////////////////////////// residue_in_chains(...) from builtins.PyCapsule residue_in_chains(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergy, rsd : rosetta.core.conformation.Residue, chains : rosetta.utility.vector1_unsigned_long) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType revamp_weight_by_burial(...) from builtins.PyCapsule revamp_weight_by_burial(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose) -> float setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextIndependentLRTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class PoissonBoltzmannEnergyCreator(EnergyMethodCreator)       Method resolution order: PoissonBoltzmannEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergyCreator,  : rosetta.core.scoring.methods.PoissonBoltzmannEnergyCreator) -> rosetta.core.scoring.methods.PoissonBoltzmannEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.PoissonBoltzmannEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new PoissonBoltzmannEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.PoissonBoltzmannEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ProClosureEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: ProClosureEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.ProClosureEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.ProClosureEnergy) -> float bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.ProClosureEnergy, pro_residue : rosetta.core.conformation.Residue, other_residue : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType   Penalize the pucker-up residue type if its chi1 is positive;  penalize the pucker-down residue type if its chi1 is negative.  Only  applies this penalty when the other_residue is the next polymeric residue  after pro_residue (i+1), unless pro_residue is an upper_term,  in which case it applies the penalty for pro_residue's previous polymeric  residue. bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.ProClosureEnergy, pro_residue : rosetta.core.conformation.Residue, other_residue : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType   Penalize the pucker-up residue type if its chi1 is positive;  penalize the pucker-down residue type if its chi1 is negative.  Only  applies this penalty when the other_residue is the next polymeric residue  after pro_residue (i+1), unless pro_residue is an upper_term,  in which case it applies the penalty for pro_residue's previous polymeric  residue. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.ProClosureEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.ProClosureEnergy, weights : rosetta.core.scoring.EMapVector) -> bool defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.ProClosureEnergy, res : rosetta.core.conformation.Residue) -> bool   Returns false if res is not a proline. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.ProClosureEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   Pro-closure terms only apply between bonded residues where i+1 is  proline -- skip residue pairs that don't apply during minimization. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.ProClosureEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   This should only be handed a proline. eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.ProClosureEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.ProClosureEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResPairMinimizationData,  : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.ProClosureEnergy,  : rosetta.utility.vector1_bool) -> NoneType   ProClosure Energy is context independent and thus  indicates that no context graphs need to  be maintained by class Energies minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.ProClosureEnergy,  : rosetta.core.pose.Pose) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.ProClosureEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between a given residue pair set_skip_ring_closure(...) from builtins.PyCapsule set_skip_ring_closure(*args, **kwargs) Overloaded function.   1. set_skip_ring_closure(rosetta.core.scoring.methods.ProClosureEnergy) -> NoneType   Sets skip_ring_closure.   2. set_skip_ring_closure(self : rosetta.core.scoring.methods.ProClosureEnergy, val : bool) -> NoneType   Sets skip_ring_closure. set_skip_ring_closure_from_flags(...) from builtins.PyCapsule set_skip_ring_closure_from_flags(rosetta.core.scoring.methods.ProClosureEnergy) -> NoneType   Queries whether the user has set the -score::no_pro_close_ring_closure flag.  If he/she has, this sets skip_ring_closure_ to 'true'. skip_ring_closure(...) from builtins.PyCapsule skip_ring_closure(rosetta.core.scoring.methods.ProClosureEnergy) -> bool   Gets skip_ring_closure. Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ProClosureEnergyCreator(EnergyMethodCreator)       Method resolution order: ProClosureEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ProClosureEnergyCreator,  : rosetta.core.scoring.methods.ProClosureEnergyCreator) -> rosetta.core.scoring.methods.ProClosureEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.ProClosureEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ProClosureEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.ProClosureEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ProQ_Energy(WholeStructureEnergy)       Method resolution order: ProQ_Energy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.ProQ_Energy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.ProQ_Energy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.ProQ_Energy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.ProQ_Energy, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.ProQ_Energy,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.ProQ_Energy, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.ProQ_Energy) -> int Methods inherited from WholeStructureEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WholeStructureEnergy,  : rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.WholeStructureEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class ProQ_EnergyCreator(EnergyMethodCreator)       Method resolution order: ProQ_EnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ProQ_EnergyCreator,  : rosetta.core.scoring.methods.ProQ_EnergyCreator) -> rosetta.core.scoring.methods.ProQ_EnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.ProQ_EnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ProQ_Energy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.ProQ_EnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class PyEnergyMethodRegistrator(builtins.object)     This class will register an instance of an EnergyMethodCreator (class T) with the ScoringManager. It will ensure that no energy method creator is registered twice, and, centralizes this registration logic so that thread safety issues can be handled in one place     Methods defined here: __init__(...) from builtins.PyCapsule __init__(self : rosetta.core.scoring.methods.PyEnergyMethodRegistrator, CreatorOP : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature.   class RG_Energy_Fast(WholeStructureEnergy)       Method resolution order: RG_Energy_Fast WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, CreatorOP : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RG_Energy_Fast,  : rosetta.core.scoring.methods.RG_Energy_Fast) -> rosetta.core.scoring.methods.RG_Energy_Fast calculate_rg_score(...) from builtins.PyCapsule calculate_rg_score(*args, **kwargs) Overloaded function.   1. calculate_rg_score(self : rosetta.core.scoring.methods.RG_Energy_Fast, pose : rosetta.core.pose.Pose) -> float   2. calculate_rg_score(self : rosetta.core.scoring.methods.RG_Energy_Fast, pose : rosetta.core.pose.Pose, relevant_residues : rosetta.utility.vector1_bool) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.RG_Energy_Fast) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.RG_Energy_Fast, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.RG_Energy_Fast, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.RG_Energy_Fast,  : rosetta.utility.vector1_bool) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.RG_Energy_Fast, pose : rosetta.core.pose.Pose, sf : rosetta.core.scoring.ScoreFunction) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.RG_Energy_Fast) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class RG_Energy_FastCreator(EnergyMethodCreator)       Method resolution order: RG_Energy_FastCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RG_Energy_FastCreator,  : rosetta.core.scoring.methods.RG_Energy_FastCreator) -> rosetta.core.scoring.methods.RG_Energy_FastCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.RG_Energy_FastCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new RG_Energy_Fast score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.RG_Energy_FastCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class RG_LocalEnergy(RG_Energy_Fast)       Method resolution order: RG_LocalEnergy RG_Energy_Fast WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RG_LocalEnergy,  : rosetta.core.scoring.methods.RG_LocalEnergy) -> rosetta.core.scoring.methods.RG_LocalEnergy calculate_rg_score(...) from builtins.PyCapsule calculate_rg_score(*args, **kwargs) Overloaded function.   1. calculate_rg_score(self : rosetta.core.scoring.methods.RG_LocalEnergy, pose : rosetta.core.pose.Pose) -> float   2. calculate_rg_score(self : rosetta.core.scoring.methods.RG_LocalEnergy, pose : rosetta.core.pose.Pose, relevant_residues : rosetta.utility.vector1_bool) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.RG_LocalEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.RG_LocalEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.RG_LocalEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.RG_LocalEnergy,  : rosetta.utility.vector1_bool) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.RG_LocalEnergy, pose : rosetta.core.pose.Pose, sf : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from RG_Energy_Fast: version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.RG_Energy_Fast) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class RG_LocalEnergyCreator(EnergyMethodCreator)       Method resolution order: RG_LocalEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RG_LocalEnergyCreator,  : rosetta.core.scoring.methods.RG_LocalEnergyCreator) -> rosetta.core.scoring.methods.RG_LocalEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.RG_LocalEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new RG_LocalEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.RG_LocalEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class RG_Local_MinData(RG_MinData)       Method resolution order: RG_Local_MinData RG_MinData rosetta.basic.datacache.CacheableData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.RG_Local_MinData) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RG_Local_MinData,  : rosetta.core.scoring.methods.RG_Local_MinData) -> rosetta.core.scoring.methods.RG_Local_MinData Methods inherited from RG_MinData: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.RG_MinData) -> rosetta.basic.datacache.CacheableData Data descriptors inherited from RG_MinData: com nres_scored rg Methods inherited from rosetta.basic.datacache.CacheableData: get_self_ptr(...) from builtins.PyCapsule get_self_ptr(*args, **kwargs) Overloaded function.   1. get_self_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.basic.datacache.CacheableData   self pointers   2. get_self_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.basic.datacache.CacheableData get_self_weak_ptr(...) from builtins.PyCapsule get_self_weak_ptr(*args, **kwargs) Overloaded function.   1. get_self_weak_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.std.weak_ptr_const_basic_datacache_CacheableData_t   2. get_self_weak_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.std.weak_ptr_basic_datacache_CacheableData_t   class RG_MinData(rosetta.basic.datacache.CacheableData)       Method resolution order: RG_MinData rosetta.basic.datacache.CacheableData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.RG_MinData) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RG_MinData,  : rosetta.core.scoring.methods.RG_MinData) -> rosetta.core.scoring.methods.RG_MinData clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.RG_MinData) -> rosetta.basic.datacache.CacheableData Data descriptors defined here: com nres_scored rg Methods inherited from rosetta.basic.datacache.CacheableData: get_self_ptr(...) from builtins.PyCapsule get_self_ptr(*args, **kwargs) Overloaded function.   1. get_self_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.basic.datacache.CacheableData   self pointers   2. get_self_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.basic.datacache.CacheableData get_self_weak_ptr(...) from builtins.PyCapsule get_self_weak_ptr(*args, **kwargs) Overloaded function.   1. get_self_weak_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.std.weak_ptr_const_basic_datacache_CacheableData_t   2. get_self_weak_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.std.weak_ptr_basic_datacache_CacheableData_t   class RMS_Energy(WholeStructureEnergy)       Method resolution order: RMS_Energy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.RMS_Energy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RMS_Energy,  : rosetta.core.scoring.methods.RMS_Energy) -> rosetta.core.scoring.methods.RMS_Energy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.RMS_Energy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.RMS_Energy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.RMS_Energy,  : rosetta.utility.vector1_bool) -> NoneType Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class RMS_EnergyCreator(EnergyMethodCreator)       Method resolution order: RMS_EnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RMS_EnergyCreator,  : rosetta.core.scoring.methods.RMS_EnergyCreator) -> rosetta.core.scoring.methods.RMS_EnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.RMS_EnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new RMS_Energy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.RMS_EnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class RamaPreProEnergy(ContextIndependentLRTwoBodyEnergy)       Method resolution order: RamaPreProEnergy ContextIndependentLRTwoBodyEnergy LongRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.RamaPreProEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.RamaPreProEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.RamaPreProEnergy,  : rosetta.core.pose.Pose) -> bool defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.RamaPreProEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.methods.RamaPreProEnergy, pose : rosetta.core.pose.Pose, rsd1 : int, rsd2 : int) -> bool eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.RamaPreProEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.RamaPreProEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.RamaPreProEnergy,  : rosetta.utility.vector1_bool) -> NoneType long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.methods.RamaPreProEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.RamaPreProEnergy,  : rosetta.core.pose.Pose) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.RamaPreProEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.RamaPreProEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextIndependentLRTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class RamaPreProEnergyCreator(EnergyMethodCreator)       Method resolution order: RamaPreProEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RamaPreProEnergyCreator,  : rosetta.core.scoring.methods.RamaPreProEnergyCreator) -> rosetta.core.scoring.methods.RamaPreProEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.RamaPreProEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new RamaPreProEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.RamaPreProEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class RamachandranEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: RamachandranEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.RamachandranEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.RamachandranEnergy, p : rosetta.core.pose.Pose) -> bool   The ramachandran energy defines derivatives for protein backbone torsion angles eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.RamachandranEnergy,  : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   NOTE: non-virtual function interface. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.RamachandranEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the phi or psi derivative for a particular residue indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.RamachandranEnergy,  : rosetta.utility.vector1_bool) -> NoneType   Ramachandran Energy is context independent and thus indicates that no context graphs need to  be maintained by class Energies minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.RamachandranEnergy,  : rosetta.core.pose.Pose) -> bool residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.RamachandranEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class RamachandranEnergy2B(ContextIndependentTwoBodyEnergy)       Method resolution order: RamachandranEnergy2B ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.RamachandranEnergy2B) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.RamachandranEnergy2B) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.RamachandranEnergy2B,  : rosetta.core.scoring.EMapVector) -> bool eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.RamachandranEnergy2B,  : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.RamachandranEnergy2B, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.RamachandranEnergy2B,  : rosetta.utility.vector1_bool) -> NoneType   Ramachandran Energy is context independent and thus indicates that no context graphs need to  be maintained by class Energies residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.RamachandranEnergy2B, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class RamachandranEnergy2BCreator(EnergyMethodCreator)       Method resolution order: RamachandranEnergy2BCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RamachandranEnergy2BCreator,  : rosetta.core.scoring.methods.RamachandranEnergy2BCreator) -> rosetta.core.scoring.methods.RamachandranEnergy2BCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.RamachandranEnergy2BCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new RamachandranEnergy2B score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.RamachandranEnergy2BCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class RamachandranEnergyCreator(EnergyMethodCreator)       Method resolution order: RamachandranEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RamachandranEnergyCreator,  : rosetta.core.scoring.methods.RamachandranEnergyCreator) -> rosetta.core.scoring.methods.RamachandranEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.RamachandranEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new RamachandranEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.RamachandranEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ReferenceEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: ReferenceEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, aa_weights_in : rosetta.utility.vector1_double) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ReferenceEnergy,  : rosetta.core.scoring.methods.ReferenceEnergy) -> rosetta.core.scoring.methods.ReferenceEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.ReferenceEnergy) -> rosetta.core.scoring.methods.EnergyMethod eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.ReferenceEnergy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float get_l_equivalent(...) from builtins.PyCapsule get_l_equivalent(self : rosetta.core.scoring.methods.ReferenceEnergy, d_aa : rosetta.core.chemical.AA) -> rosetta.core.chemical.AA indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.ReferenceEnergy,  : rosetta.utility.vector1_bool) -> NoneType   DunbrackEnergy is context independent; indicates that no  context graphs are required is_d_aminoacid(...) from builtins.PyCapsule is_d_aminoacid(self : rosetta.core.scoring.methods.ReferenceEnergy, res_aa : rosetta.core.chemical.AA) -> bool minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.ReferenceEnergy,  : rosetta.core.pose.Pose) -> bool residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.ReferenceEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ReferenceEnergyCreator(EnergyMethodCreator)       Method resolution order: ReferenceEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ReferenceEnergyCreator,  : rosetta.core.scoring.methods.ReferenceEnergyCreator) -> rosetta.core.scoring.methods.ReferenceEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.ReferenceEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ReferenceEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.ReferenceEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ReferenceEnergyNoncanonical(ContextIndependentOneBodyEnergy)       Method resolution order: ReferenceEnergyNoncanonical ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, weight_list : rosetta.utility.vector1_double) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ReferenceEnergyNoncanonical,  : rosetta.core.scoring.methods.ReferenceEnergyNoncanonical) -> rosetta.core.scoring.methods.ReferenceEnergyNoncanonical clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.ReferenceEnergyNoncanonical) -> rosetta.core.scoring.methods.EnergyMethod eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.ReferenceEnergyNoncanonical, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.ReferenceEnergyNoncanonical,  : rosetta.utility.vector1_bool) -> NoneType   DunbrackEnergy is context independent; indicates that no  context graphs are required init_res_list(...) from builtins.PyCapsule init_res_list(rosetta.core.scoring.methods.ReferenceEnergyNoncanonical) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.ReferenceEnergyNoncanonical, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ReferenceEnergyNoncanonicalCreator(EnergyMethodCreator)       Method resolution order: ReferenceEnergyNoncanonicalCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ReferenceEnergyNoncanonicalCreator,  : rosetta.core.scoring.methods.ReferenceEnergyNoncanonicalCreator) -> rosetta.core.scoring.methods.ReferenceEnergyNoncanonicalCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.ReferenceEnergyNoncanonicalCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ReferenceEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.ReferenceEnergyNoncanonicalCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ResidualDipolarCouplingEnergy(WholeStructureEnergy)       Method resolution order: ResidualDipolarCouplingEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy,  : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy) -> rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy) -> rosetta.core.scoring.methods.EnergyMethod eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_dipolar(...) from builtins.PyCapsule eval_dipolar(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy, pose : rosetta.core.pose.Pose, rdc_data : rosetta.core.scoring.ResidualDipolarCoupling) -> float finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy,  : rosetta.utility.vector1_bool) -> NoneType setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ResidualDipolarCouplingEnergyCreator(EnergyMethodCreator)       Method resolution order: ResidualDipolarCouplingEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergyCreator,  : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergyCreator) -> rosetta.core.scoring.methods.ResidualDipolarCouplingEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ResidualDipolarCouplingEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.ResidualDipolarCouplingEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ResidualDipolarCouplingEnergy_Rohl(WholeStructureEnergy)       Method resolution order: ResidualDipolarCouplingEnergy_Rohl WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_Rohl,  : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_Rohl) -> rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_Rohl clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_Rohl) -> rosetta.core.scoring.methods.EnergyMethod finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_Rohl, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_Rohl,  : rosetta.utility.vector1_bool) -> NoneType Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ResidualDipolarCouplingEnergy_RohlCreator(EnergyMethodCreator)       Method resolution order: ResidualDipolarCouplingEnergy_RohlCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_RohlCreator,  : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_RohlCreator) -> rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_RohlCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_RohlCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ResidualDipolarCouplingEnergy_Rohl score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.ResidualDipolarCouplingEnergy_RohlCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ResidueCartBondedParameters(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_angle_parameter(...) from builtins.PyCapsule add_angle_parameter(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, atom_inds : rosetta.utility.fixedsizearray1_unsigned_long_3_t,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType add_bbdep_angle_parameter(...) from builtins.PyCapsule add_bbdep_angle_parameter(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, atom_inds : rosetta.utility.fixedsizearray1_unsigned_long_3_t,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType add_bbdep_length_parameter(...) from builtins.PyCapsule add_bbdep_length_parameter(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, atom_inds : rosetta.utility.fixedsizearray1_unsigned_long_2_t,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType add_improper_torsion_parameter(...) from builtins.PyCapsule add_improper_torsion_parameter(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, atom_inds : rosetta.utility.fixedsizearray1_unsigned_long_4_t,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType add_length_parameter(...) from builtins.PyCapsule add_length_parameter(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, atom_inds : rosetta.utility.fixedsizearray1_unsigned_long_2_t,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType add_lower_connect_angle_params(...) from builtins.PyCapsule add_lower_connect_angle_params(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, atom_inds : rosetta.utility.fixedsizearray1_unsigned_long_3_t,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType add_torsion_parameter(...) from builtins.PyCapsule add_torsion_parameter(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, atom_inds : rosetta.utility.fixedsizearray1_unsigned_long_4_t,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType add_upper_connect_angle_params(...) from builtins.PyCapsule add_upper_connect_angle_params(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, atom_inds : rosetta.utility.fixedsizearray1_unsigned_long_3_t,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType angle_parameters(...) from builtins.PyCapsule angle_parameters(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.utility.vector1_std_pair_utility_fixedsizearray1_unsigned_long_3_std_shared_ptr_const_core_scoring_methods_CartBondedParameters_t assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ResidueCartBondedParameters,  : rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.core.scoring.methods.ResidueCartBondedParameters bb_CA_index(...) from builtins.PyCapsule bb_CA_index(*args, **kwargs) Overloaded function.   1. bb_CA_index(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, index : int) -> NoneType   2. bb_CA_index(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> int bb_C_index(...) from builtins.PyCapsule bb_C_index(*args, **kwargs) Overloaded function.   1. bb_C_index(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, index : int) -> NoneType   2. bb_C_index(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> int bb_H_index(...) from builtins.PyCapsule bb_H_index(*args, **kwargs) Overloaded function.   1. bb_H_index(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, index : int) -> NoneType   2. bb_H_index(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> int bb_N_index(...) from builtins.PyCapsule bb_N_index(*args, **kwargs) Overloaded function.   1. bb_N_index(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, index : int) -> NoneType   2. bb_N_index(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> int bb_O_index(...) from builtins.PyCapsule bb_O_index(*args, **kwargs) Overloaded function.   1. bb_O_index(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, index : int) -> NoneType   2. bb_O_index(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> int bbdep_angle_parameters(...) from builtins.PyCapsule bbdep_angle_parameters(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.utility.vector1_std_pair_utility_fixedsizearray1_unsigned_long_3_std_shared_ptr_const_core_scoring_methods_CartBondedParameters_t   just the list of angle parameters that are dependent on phi and psi; used for calculating dE/dphi and dE/dpsi bbdep_length_parameters(...) from builtins.PyCapsule bbdep_length_parameters(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.utility.vector1_std_pair_utility_fixedsizearray1_unsigned_long_2_std_shared_ptr_const_core_scoring_methods_CartBondedParameters_t   just the list of length parameters that are dependent on phi and psi; used for calculating dE/dphi and dE/dpsi ca_cprev_n_h_interres_torsion_params(...) from builtins.PyCapsule ca_cprev_n_h_interres_torsion_params(*args, **kwargs) Overloaded function.   1. ca_cprev_n_h_interres_torsion_params(self : rosetta.core.scoring.methods.ResidueCartBondedParameters,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType   2. ca_cprev_n_h_interres_torsion_params(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.core.scoring.methods.CartBondedParameters ca_nnext_c_o_interres_torsion_params(...) from builtins.PyCapsule ca_nnext_c_o_interres_torsion_params(*args, **kwargs) Overloaded function.   1. ca_nnext_c_o_interres_torsion_params(self : rosetta.core.scoring.methods.ResidueCartBondedParameters,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType   2. ca_nnext_c_o_interres_torsion_params(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.core.scoring.methods.CartBondedParameters cprev_n_bond_length_params(...) from builtins.PyCapsule cprev_n_bond_length_params(*args, **kwargs) Overloaded function.   1. cprev_n_bond_length_params(self : rosetta.core.scoring.methods.ResidueCartBondedParameters,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType   2. cprev_n_bond_length_params(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.core.scoring.methods.CartBondedParameters improper_torsion_parameters(...) from builtins.PyCapsule improper_torsion_parameters(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.utility.vector1_std_pair_utility_fixedsizearray1_unsigned_long_4_std_shared_ptr_const_core_scoring_methods_CartBondedParameters_t   Exactly the same as proper torsion parameters, but parceled out  into their own section so that debugging information can be given for  these torsions in particular. length_parameters(...) from builtins.PyCapsule length_parameters(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.utility.vector1_std_pair_utility_fixedsizearray1_unsigned_long_2_std_shared_ptr_const_core_scoring_methods_CartBondedParameters_t lower_connect_angle_params(...) from builtins.PyCapsule lower_connect_angle_params(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.utility.vector1_std_pair_utility_fixedsizearray1_unsigned_long_3_std_shared_ptr_const_core_scoring_methods_CartBondedParameters_t oprev_cprev_n_h_interres_torsion_params(...) from builtins.PyCapsule oprev_cprev_n_h_interres_torsion_params(*args, **kwargs) Overloaded function.   1. oprev_cprev_n_h_interres_torsion_params(self : rosetta.core.scoring.methods.ResidueCartBondedParameters,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType   2. oprev_cprev_n_h_interres_torsion_params(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.core.scoring.methods.CartBondedParameters pro_CD_index(...) from builtins.PyCapsule pro_CD_index(*args, **kwargs) Overloaded function.   1. pro_CD_index(self : rosetta.core.scoring.methods.ResidueCartBondedParameters, index : int) -> NoneType   2. pro_CD_index(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> int pro_cd_cprev_n_ca_interres_torsion_params(...) from builtins.PyCapsule pro_cd_cprev_n_ca_interres_torsion_params(*args, **kwargs) Overloaded function.   1. pro_cd_cprev_n_ca_interres_torsion_params(self : rosetta.core.scoring.methods.ResidueCartBondedParameters,  : rosetta.core.scoring.methods.CartBondedParameters) -> NoneType   2. pro_cd_cprev_n_ca_interres_torsion_params(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.core.scoring.methods.CartBondedParameters torsion_parameters(...) from builtins.PyCapsule torsion_parameters(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.utility.vector1_std_pair_utility_fixedsizearray1_unsigned_long_4_std_shared_ptr_const_core_scoring_methods_CartBondedParameters_t upper_connect_angle_params(...) from builtins.PyCapsule upper_connect_angle_params(rosetta.core.scoring.methods.ResidueCartBondedParameters) -> rosetta.utility.vector1_std_pair_utility_fixedsizearray1_unsigned_long_3_std_shared_ptr_const_core_scoring_methods_CartBondedParameters_t   class RingClosureEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: RingClosureEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.RingClosureEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RingClosureEnergy,  : rosetta.core.scoring.methods.RingClosureEnergy) -> rosetta.core.scoring.methods.RingClosureEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.RingClosureEnergy) -> rosetta.core.scoring.methods.EnergyMethod   Clone -- creates a copy and returns an owning pointer to the copy. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.RingClosureEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms in this residue. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.RingClosureEnergy,  : rosetta.utility.vector1_bool) -> NoneType   RingClosure Energy is context independent and thus indicates that no context graphs need to  be maintained by class Energies minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.RingClosureEnergy,  : rosetta.core.pose.Pose) -> bool residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.RingClosureEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class RingClosureEnergyCreator(EnergyMethodCreator)       Method resolution order: RingClosureEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.RingClosureEnergyCreator,  : rosetta.core.scoring.methods.RingClosureEnergyCreator) -> rosetta.core.scoring.methods.RingClosureEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.RingClosureEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new RingClosureEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.RingClosureEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class SASAEnergy(ContextIndependentLRTwoBodyEnergy)       Method resolution order: SASAEnergy ContextIndependentLRTwoBodyEnergy LongRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.SASAEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.SASAEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.SASAEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.methods.SASAEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.SASAEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.SASAEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.SASAEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.SASAEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.SASAEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.SASAEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.SASAEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.SASAEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.SASAEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.SASAEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.methods.SASAEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType packing_interaction_cutoff(...) from builtins.PyCapsule packing_interaction_cutoff(rosetta.core.scoring.methods.SASAEnergy) -> float   this is our own special function prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.SASAEnergy, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.SASAEnergy,  : rosetta.core.pose.Pose) -> bool requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.SASAEnergy,  : rosetta.core.pose.Pose) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.SASAEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.SASAEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pairdata : rosetta.core.scoring.ResPairMinimizationData,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.SASAEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.SASAEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.SASAEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase, resdata : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.SASAEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase, res1data : rosetta.core.scoring.ResSingleMinimizationData, res2data : rosetta.core.scoring.ResSingleMinimizationData, pairdata : rosetta.core.scoring.ResPairMinimizationData) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.SASAEnergy, pose : rosetta.core.pose.Pose, residues_repacking : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.SASAEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.SASAEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, resdata : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.SASAEnergy,  : rosetta.core.pose.Pose, resid : int) -> NoneType use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.SASAEnergy) -> bool use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.SASAEnergy) -> bool Methods inherited from ContextIndependentLRTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class SASAEnergyCreator(EnergyMethodCreator)       Method resolution order: SASAEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SASAEnergyCreator,  : rosetta.core.scoring.methods.SASAEnergyCreator) -> rosetta.core.scoring.methods.SASAEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.SASAEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new SASAEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.SASAEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class SA_Energy(WholeStructureEnergy)       Method resolution order: SA_Energy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SA_Energy,  : rosetta.core.scoring.methods.SA_Energy) -> rosetta.core.scoring.methods.SA_Energy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.SA_Energy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.SA_Energy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.SA_Energy,  : rosetta.utility.vector1_bool) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.SA_Energy) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class SA_EnergyCreator(EnergyMethodCreator)       Method resolution order: SA_EnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SA_EnergyCreator,  : rosetta.core.scoring.methods.SA_EnergyCreator) -> rosetta.core.scoring.methods.SA_EnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.SA_EnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new SA_Energy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.SA_EnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class SSElementMotifContactEnergy(WholeStructureEnergy)       Method resolution order: SSElementMotifContactEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.SSElementMotifContactEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SSElementMotifContactEnergy,  : rosetta.core.scoring.methods.SSElementMotifContactEnergy) -> rosetta.core.scoring.methods.SSElementMotifContactEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.SSElementMotifContactEnergy) -> rosetta.core.scoring.methods.EnergyMethod finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.SSElementMotifContactEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   Called at the end of the energy evaluation. get_SSelements_in_contact(...) from builtins.PyCapsule get_SSelements_in_contact(self : rosetta.core.scoring.methods.SSElementMotifContactEnergy, element : int, ssElements : rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t, pose : rosetta.core.pose.Pose) -> int get_ss_elements(...) from builtins.PyCapsule get_ss_elements(self : rosetta.core.scoring.methods.SSElementMotifContactEnergy, pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.SSElementMotifContactEnergy,  : rosetta.utility.vector1_bool) -> NoneType version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.SSElementMotifContactEnergy) -> int which_ssElement(...) from builtins.PyCapsule which_ssElement(self : rosetta.core.scoring.methods.SSElementMotifContactEnergy, res : int, ssElements : rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t) -> int Methods inherited from WholeStructureEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class SSElementMotifContactEnergyCreator(EnergyMethodCreator)       Method resolution order: SSElementMotifContactEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SSElementMotifContactEnergyCreator,  : rosetta.core.scoring.methods.SSElementMotifContactEnergyCreator) -> rosetta.core.scoring.methods.SSElementMotifContactEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.SSElementMotifContactEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new MotifEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.SSElementMotifContactEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class SecondaryStructureEnergy(WholeStructureEnergy)       Method resolution order: SecondaryStructureEnergy WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.SecondaryStructureEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.SecondaryStructureEnergy) -> float   The SecondaryStructureEnergy class requires that the EnergyGraph  span 12 Angstroms between centroids.  The centroids residues build-in a  3 Angstrom radius each. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.SecondaryStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.SecondaryStructureEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.SecondaryStructureEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.SecondaryStructureEnergy, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from WholeStructureEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WholeStructureEnergy,  : rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.WholeStructureEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class SecondaryStructureEnergyCreator(EnergyMethodCreator)       Method resolution order: SecondaryStructureEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SecondaryStructureEnergyCreator,  : rosetta.core.scoring.methods.SecondaryStructureEnergyCreator) -> rosetta.core.scoring.methods.SecondaryStructureEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.SecondaryStructureEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new SecondaryStructureEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.SecondaryStructureEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class SequenceDependentRefEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: SequenceDependentRefEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, aa_seq_weights_in : rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SequenceDependentRefEnergy,  : rosetta.core.scoring.methods.SequenceDependentRefEnergy) -> rosetta.core.scoring.methods.SequenceDependentRefEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.SequenceDependentRefEnergy) -> rosetta.core.scoring.methods.EnergyMethod eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.SequenceDependentRefEnergy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.SequenceDependentRefEnergy,  : rosetta.utility.vector1_bool) -> NoneType   DunbrackEnergy is context independent; indicates that no  context graphs are required minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.SequenceDependentRefEnergy,  : rosetta.core.pose.Pose) -> bool residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.SequenceDependentRefEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class SequenceDependentRefEnergyCreator(EnergyMethodCreator)       Method resolution order: SequenceDependentRefEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SequenceDependentRefEnergyCreator,  : rosetta.core.scoring.methods.SequenceDependentRefEnergyCreator) -> rosetta.core.scoring.methods.SequenceDependentRefEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.SequenceDependentRefEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new SequenceDependentRefEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.SequenceDependentRefEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class ShortRangeTwoBodyEnergy(TwoBodyEnergy)       Method resolution order: ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy,  : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy,  : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff(). divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, weights : rosetta.core.scoring.EMapVector) -> bool   Two body energies are able to define intra-residue energies, and to do so  only in the presence of certain non-zero weights.  The ScoreFunction will hand over its  weight set as it asks whether the energy method defines an intraresidue energy or not.    For example, the Etable method defines intra-residue energies only when one or more  of the fa_intra_{atr,rep,sol} weights are non-zero. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between a given residue pair  accumulating the unweighted energies in an EnergyMap residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethodType   Return one of the 7 kinds of energy methods that exist:  e.g. context-dependent-one-body vs whole-structure. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class SmoothCenPairEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: SmoothCenPairEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.SmoothCenPairEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.SmoothCenPairEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.SmoothCenPairEnergy,  : rosetta.core.scoring.EMapVector) -> bool   This method *should* admit to defining intraresidue energies eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.SmoothCenPairEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.SmoothCenPairEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.SmoothCenPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.SmoothCenPairEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.SmoothCenPairEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.SmoothCenPairEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class SmoothCenPairEnergyCreator(EnergyMethodCreator)       Method resolution order: SmoothCenPairEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SmoothCenPairEnergyCreator,  : rosetta.core.scoring.methods.SmoothCenPairEnergyCreator) -> rosetta.core.scoring.methods.SmoothCenPairEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.SmoothCenPairEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new SmoothCenPairEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.SmoothCenPairEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class SmoothEnvEnergy(ContextDependentOneBodyEnergy)       Method resolution order: SmoothEnvEnergy ContextDependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.SmoothEnvEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.SmoothEnvEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.SmoothEnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.SmoothEnvEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.SmoothEnvEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.SmoothEnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.SmoothEnvEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextDependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextDependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the cd_1b element of the EnergyMethodType enumeration; this method  should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class SmoothEnvEnergyCreator(EnergyMethodCreator)       Method resolution order: SmoothEnvEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SmoothEnvEnergyCreator,  : rosetta.core.scoring.methods.SmoothEnvEnergyCreator) -> rosetta.core.scoring.methods.SmoothEnvEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.SmoothEnvEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new SmoothEnvEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.SmoothEnvEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class SplitUnfoldedTwoBodyEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: SplitUnfoldedTwoBodyEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, label_type : str, value_type : str, score_func_type : str) -> NoneType   2. __init__(self : handle, label_type : str, value_type : str, score_func_type : str, emap_in : rosetta.core.scoring.EMapVector) -> NoneType   3. __init__(handle, rosetta.core.scoring.methods.SplitUnfoldedTwoBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.SplitUnfoldedTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethod indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.SplitUnfoldedTwoBodyEnergy,  : rosetta.utility.vector1_bool) -> NoneType minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.SplitUnfoldedTwoBodyEnergy,  : rosetta.core.pose.Pose) -> bool residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.SplitUnfoldedTwoBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType Methods inherited from ContextIndependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class SplitUnfoldedTwoBodyEnergyCreator(EnergyMethodCreator)       Method resolution order: SplitUnfoldedTwoBodyEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SplitUnfoldedTwoBodyEnergyCreator,  : rosetta.core.scoring.methods.SplitUnfoldedTwoBodyEnergyCreator) -> rosetta.core.scoring.methods.SplitUnfoldedTwoBodyEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.SplitUnfoldedTwoBodyEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.SplitUnfoldedTwoBodyEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class SuckerEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: SuckerEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SuckerEnergy,  : rosetta.core.scoring.methods.SuckerEnergy) -> rosetta.core.scoring.methods.SuckerEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.SuckerEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.SuckerEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.SuckerEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.SuckerEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.SuckerEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.SuckerEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType interaction_cutoff(...) from builtins.PyCapsule interaction_cutoff(rosetta.core.scoring.methods.SuckerEnergy) -> float   non-virtual accessor for speed residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.SuckerEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// Methods inherited from ContextIndependentTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class SuckerEnergyCreator(EnergyMethodCreator)       Method resolution order: SuckerEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SuckerEnergyCreator,  : rosetta.core.scoring.methods.SuckerEnergyCreator) -> rosetta.core.scoring.methods.SuckerEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.SuckerEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new SuckerEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.SuckerEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class SymmetricLigandEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: SymmetricLigandEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SymmetricLigandEnergy,  : rosetta.core.scoring.methods.SymmetricLigandEnergy) -> rosetta.core.scoring.methods.SymmetricLigandEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.SymmetricLigandEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.SymmetricLigandEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.SymmetricLigandEnergy,  : rosetta.utility.vector1_bool) -> NoneType   SymmetricLigandEnergy is context independent; indicates that no  context graphs are required residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.SymmetricLigandEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.SymmetricLigandEnergy) -> int Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class SymmetricLigandEnergyCreator(EnergyMethodCreator)       Method resolution order: SymmetricLigandEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.SymmetricLigandEnergyCreator,  : rosetta.core.scoring.methods.SymmetricLigandEnergyCreator) -> rosetta.core.scoring.methods.SymmetricLigandEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.SymmetricLigandEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new DunbrackEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.SymmetricLigandEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class TwoBodyEnergy(EnergyMethod)       Method resolution order: TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.TwoBodyEnergy, rosetta.core.scoring.methods.TwoBodyEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.scoring.methods.TwoBodyEnergy) -> rosetta.core.scoring.methods.TwoBodyEnergy backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, weights : rosetta.core.scoring.EMapVector) -> bool   Two body energies are able to define intra-residue energies, and to do so  only in the presence of certain non-zero weights.  The ScoreFunction will hand over its  weight set as it asks whether the energy method defines an intraresidue energy or not.    For example, the Etable method defines intra-residue energies only when one or more  of the fa_intra_{atr,rep,sol} weights are non-zero. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between a given residue pair  accumulating the unweighted energies in an EnergyMap residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethodType   Return one of the 7 kinds of energy methods that exist:  e.g. context-dependent-one-body vs whole-structure. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class UnfoldedStateEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: UnfoldedStateEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, type : str) -> NoneType   2. __init__(self : handle, type : str, emap_in : rosetta.core.scoring.EMapVector) -> NoneType   3. __init__(handle, rosetta.core.scoring.methods.UnfoldedStateEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.UnfoldedStateEnergy) -> rosetta.core.scoring.methods.EnergyMethod indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.UnfoldedStateEnergy,  : rosetta.utility.vector1_bool) -> NoneType minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.UnfoldedStateEnergy,  : rosetta.core.pose.Pose) -> bool residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.UnfoldedStateEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType Methods inherited from ContextIndependentOneBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class UnfoldedStateEnergyCreator(EnergyMethodCreator)       Method resolution order: UnfoldedStateEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.UnfoldedStateEnergyCreator,  : rosetta.core.scoring.methods.UnfoldedStateEnergyCreator) -> rosetta.core.scoring.methods.UnfoldedStateEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.UnfoldedStateEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new UnfoldedStateEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.UnfoldedStateEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class VdWTinkerEnergy(ContextIndependentLRTwoBodyEnergy)       Method resolution order: VdWTinkerEnergy ContextIndependentLRTwoBodyEnergy LongRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, options : rosetta.core.scoring.methods.EnergyMethodOptions) -> NoneType   2. __init__(handle, rosetta.core.scoring.methods.VdWTinkerEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.VdWTinkerEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.VdWTinkerEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.methods.VdWTinkerEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.VdWTinkerEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.VdWTinkerEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.VdWTinkerEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.VdWTinkerEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.VdWTinkerEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.VdWTinkerEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.VdWTinkerEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.VdWTinkerEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.VdWTinkerEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.VdWTinkerEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.methods.VdWTinkerEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType packing_interaction_cutoff(...) from builtins.PyCapsule packing_interaction_cutoff(rosetta.core.scoring.methods.VdWTinkerEnergy) -> float   this is our own special function prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.VdWTinkerEnergy, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.VdWTinkerEnergy,  : rosetta.core.pose.Pose) -> bool requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.VdWTinkerEnergy,  : rosetta.core.pose.Pose) -> bool residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.VdWTinkerEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.VdWTinkerEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pairdata : rosetta.core.scoring.ResPairMinimizationData,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.VdWTinkerEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.VdWTinkerEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.VdWTinkerEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase, resdata : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.VdWTinkerEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase, res1data : rosetta.core.scoring.ResSingleMinimizationData, res2data : rosetta.core.scoring.ResSingleMinimizationData, pairdata : rosetta.core.scoring.ResPairMinimizationData) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.VdWTinkerEnergy, pose : rosetta.core.pose.Pose, residues_repacking : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.VdWTinkerEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.VdWTinkerEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, resdata : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.VdWTinkerEnergy,  : rosetta.core.pose.Pose, resid : int) -> NoneType use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.VdWTinkerEnergy) -> bool use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.VdWTinkerEnergy) -> bool Methods inherited from ContextIndependentLRTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class VdWTinkerEnergyCreator(EnergyMethodCreator)       Method resolution order: VdWTinkerEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.VdWTinkerEnergyCreator,  : rosetta.core.scoring.methods.VdWTinkerEnergyCreator) -> rosetta.core.scoring.methods.VdWTinkerEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.VdWTinkerEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new VdWTinkerEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.VdWTinkerEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class WaterAdductHBondEnergy(ContextIndependentTwoBodyEnergy)       Method resolution order: WaterAdductHBondEnergy ContextIndependentTwoBodyEnergy ShortRangeTwoBodyEnergy TwoBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WaterAdductHBondEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.WaterAdductHBondEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.methods.WaterAdductHBondEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.WaterAdductHBondEnergy, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.methods.WaterAdductHBondEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType get_atom_h2o_hbond_derivative(...) from builtins.PyCapsule get_atom_h2o_hbond_derivative(self : rosetta.core.scoring.methods.WaterAdductHBondEnergy, atom : rosetta.core.id.AtomID, hbond_set : rosetta.core.scoring.hbonds.HBondSet, weights : rosetta.core.scoring.EMapVector, f1 : rosetta.numeric.xyzVector_double_t, f2 : rosetta.numeric.xyzVector_double_t) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.WaterAdductHBondEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.methods.WaterAdductHBondEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.WaterAdductHBondEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   ////////////////////////////////////////////////////////////////////////// setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.WaterAdductHBondEnergy, pose : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.WaterAdductHBondEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from ContextIndependentTwoBodyEnergy: assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy,  : rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from ShortRangeTwoBodyEnergy: divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) -> bool   A derived class should return true for this function if it implements its own  versions of the backbone_backbone_energy, backbone_sidechain_energy and  sidechain_sidechain_energy functions.  The default sidechain_sidechain_energy implemented  by the TwoBodyEnergy base class calls residue_pair_energy.  If the derived class implements its own  versions of these functions, then calling code may avoid calling it on pairs of residues  that are "provably distant" based on a pair of bounding spheres for a sidechains and  backbones and this method's atomic_interaction_cutoff energy method. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamer  Since short range rotamer pairs may not need calculation, the default method  looks at blocks of residue type pairs and only calls the residue_pair_energy method  if the rotamer pairs are within range evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls derived class's residue_pair_energy method.  Since short range rotamer pairs  may not need calculation, the default method looks at blocks of residue type pairs  and only calls the residue_pair_energy method if the rotamer pairs are within range Methods inherited from TwoBodyEnergy: backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  backbone of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the weighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the backbone of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. bump_energy_backbone(...) from builtins.PyCapsule bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType bump_energy_full(...) from builtins.PyCapsule bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType defines_intrares_dof_derivatives(...) from builtins.PyCapsule defines_intrares_dof_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_intrares_energy_for_residue(...) from builtins.PyCapsule defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : rosetta.core.conformation.Residue) -> bool   If a score function defines no intra-residue scores for a particular  residue, then it may opt-out of being asked during minimization to evaluate  the score for this residue. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class WaterAdductHBondEnergyCreator(EnergyMethodCreator)       Method resolution order: WaterAdductHBondEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WaterAdductHBondEnergyCreator,  : rosetta.core.scoring.methods.WaterAdductHBondEnergyCreator) -> rosetta.core.scoring.methods.WaterAdductHBondEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.WaterAdductHBondEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new WaterAdductHBondEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.WaterAdductHBondEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class WaterAdductIntraEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: WaterAdductIntraEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WaterAdductIntraEnergy,  : rosetta.core.scoring.methods.WaterAdductIntraEnergy) -> rosetta.core.scoring.methods.WaterAdductIntraEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.WaterAdductIntraEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.WaterAdductIntraEnergy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.WaterAdductIntraEnergy,  : rosetta.utility.vector1_bool) -> NoneType   WaterAdductIntraEnergy is context independent; indicates that no  context graphs are required residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.WaterAdductIntraEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.WaterAdductIntraEnergy) -> int Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class WaterAdductIntraEnergyCreator(EnergyMethodCreator)       Method resolution order: WaterAdductIntraEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WaterAdductIntraEnergyCreator,  : rosetta.core.scoring.methods.WaterAdductIntraEnergyCreator) -> rosetta.core.scoring.methods.WaterAdductIntraEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.WaterAdductIntraEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new WaterAdductIntraEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.WaterAdductIntraEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class WholeStructureEnergy(EnergyMethod)     Base class for EnergyMethods which are meaningful only on entire structures, for example, the Radius of Gyration.  These EnergyMethods do all of their work in the "finalize_total_energy" section of score function evaluation.     Method resolution order: WholeStructureEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.methods.WholeStructureEnergy,  : rosetta.core.scoring.methods.EnergyMethodCreator) -> NoneType   2. __init__(rosetta.core.scoring.methods.WholeStructureEnergy, rosetta.core.scoring.methods.WholeStructureEnergy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.WholeStructureEnergy,  : rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.WholeStructureEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.methods.WholeStructureEnergy) -> float   how far apart must two heavy atoms be to have a zero interaction energy?      If hydrogen atoms interact at the same range as heavy atoms, then  this distance should build-in a 2 * max-bound-h-distance-cutoff buffer.  There is an improper mixing here between run-time aquired chemical knowledge  (max-bound-h-distance-cutoff) and compile time aquired scoring knowledge  (max atom cutoff); this could be resolved by adding a boolean  uses_hydrogen_interaction_distance() to the SRTBEnergy class along with  a method of the ChemicalManager max_bound_h_distance_cutoff().    This method allows the WholeStructureEnergy class to define which edges  should be included in the EnergyGraph so that during the finalize() method  the Energy class can iterate across the EnergyGraph.  This iteration occurrs  in the SecondaryStructureEnergy class, where the edges must span 12 angstroms  between the centroids.  Arguably, the SecondaryStructureEnergy class could use  the TwelveANeighborGraph (a context graph) and not require that the EnergyGraph  span such long distances. method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.WholeStructureEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from EnergyMethod: clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.core.scoring.methods.EnergyMethod defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.EnergyMethod, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType   Indicate in the context-graphs-required list which  context-graphs this energy method requires that the Pose  maintain when doing neighbor evaluation.  Context graphs are  allowed minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class YHHPlanarityEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: YHHPlanarityEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.YHHPlanarityEnergy,  : rosetta.core.scoring.methods.YHHPlanarityEnergy) -> rosetta.core.scoring.methods.YHHPlanarityEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.YHHPlanarityEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.YHHPlanarityEnergy, p : rosetta.core.pose.Pose) -> bool   The P_AA_pp energy function describes derivatives wrt phi and psi. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.YHHPlanarityEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the P_AA_pp DOF derivative for a particular residue. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.YHHPlanarityEnergy,  : rosetta.utility.vector1_bool) -> NoneType   P_AA_pp_Energy is context independent; indicates that no  context graphs are required minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.YHHPlanarityEnergy,  : rosetta.core.pose.Pose) -> bool residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.YHHPlanarityEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.YHHPlanarityEnergy) -> int Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing.   class YHHPlanarityEnergyCreator(EnergyMethodCreator)       Method resolution order: YHHPlanarityEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.YHHPlanarityEnergyCreator,  : rosetta.core.scoring.methods.YHHPlanarityEnergyCreator) -> rosetta.core.scoring.methods.YHHPlanarityEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.YHHPlanarityEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new YHHPlanarityEnergy object score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.YHHPlanarityEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function   class pHEnergy(ContextIndependentOneBodyEnergy)       Method resolution order: pHEnergy ContextIndependentOneBodyEnergy OneBodyEnergy EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.pHEnergy,  : rosetta.core.scoring.methods.pHEnergy) -> rosetta.core.scoring.methods.pHEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.methods.pHEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone eval_dof_derivative(...) from builtins.PyCapsule eval_dof_derivative(self : rosetta.core.scoring.methods.pHEnergy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.methods.pHEnergy,  : rosetta.utility.vector1_bool) -> NoneType residue_energy(...) from builtins.PyCapsule residue_energy(self : rosetta.core.scoring.methods.pHEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   ////////////////////////////////////////////////////////////////////////// set_pH(...) from builtins.PyCapsule set_pH( : float) -> NoneType Methods inherited from ContextIndependentOneBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType   Returns the ci_1b element of the EnergyMethodType enumeration; this  method should NOT be overridden by derived classes. Methods inherited from OneBodyEnergy: defines_dof_derivatives(...) from builtins.PyCapsule defines_dof_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, p : rosetta.core.pose.Pose) -> bool   Use the dof_derivative interface for this energy method when  calculating derivatives?  It is possible to define both dof_derivatives and  atom-derivatives; they are not mutually exclusive. defines_score_for_residue(...) from builtins.PyCapsule defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default behavior is to return "true" for all residues. eval_residue_derivatives(...) from builtins.PyCapsule eval_residue_derivatives(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on this residue and increment them  into the input atom_derivs vector1.  The calling function must guarantee that  setup for derivatives is called before this function is, and that the atom_derivs  vector contains at least as many entries as there are atoms in the input Residue.  This base class provides a default noop implementation of this function. eval_residue_dof_derivative(...) from builtins.PyCapsule eval_residue_dof_derivative(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. residue_energy_ext(...) from builtins.PyCapsule residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the one-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  one body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object  for the given residue in a call to setup_for_minimizing_for_residue before this function is  invoked. This function should not be called unless the use_extended_residue_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). The Pose merely serves as context, and the input residue is not required  to be a member of the Pose. setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResSingleMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase.   The Pose merely serves as context, and the input residue is not  required to be a member of the Pose. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue, who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed use_extended_residue_energy_interface(...) from builtins.PyCapsule use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool   Rely on the extended version of the residue_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.  Return 'true' for the extended version.  The default method implemented in this class returns 'false' Methods inherited from EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, total_energy : rosetta.core.scoring.EMapVector) -> NoneType   called by the ScoreFunction at the end of energy evaluation.  The derived class has the opportunity to accumulate a score  into the pose's total_energy EnergyMap.  WholeStructure energies  operate within this method; any method using a NeighborList during  minimization would also operate within this function call. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType   Called immediately before atom- and DOF-derivatives are calculated  allowing the derived class a chance to prepare for future calls. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   if an energy method needs to cache something in the pose (e.g. in pose.energies()),  before scoring begins, it must do so in this method.  All long range energy  functions must initialize their LREnergyContainers before scoring begins.  The default is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class pHEnergyCreator(EnergyMethodCreator)       Method resolution order: pHEnergyCreator EnergyMethodCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.methods.pHEnergyCreator,  : rosetta.core.scoring.methods.pHEnergyCreator) -> rosetta.core.scoring.methods.pHEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.methods.pHEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new pHEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.methods.pHEnergyCreator) -> rosetta.utility.vector1_core_scoring_ScoreType   Return the set of score types claimed by the EnergyMethod  this EnergyMethodCreator creates in its create_energy_method() function