Bindings for core::scoring::elec namespace

Classes
		builtins.object ElecGroup GroupElec weight_triple rosetta.basic.datacache.CacheableData(builtins.object) FAElecContextData rosetta.core.conformation.Atom(builtins.object) ElecAtom rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) FA_GrpElecEnergy rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy(rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy) FA_ElecEnergy FA_ElecEnergyAroAll FA_ElecEnergyAroAro RNA_FA_ElecEnergy rosetta.core.scoring.methods.EnergyMethodCreator(builtins.object) FA_ElecEnergyAroAllCreator FA_ElecEnergyAroAroCreator FA_ElecEnergyCreator FA_GrpElecEnergyCreator RNA_FA_ElecEnergyCreator   class ElecAtom(rosetta.core.conformation.Atom)       Method resolution order: ElecAtom rosetta.core.conformation.Atom builtins.object Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(self : rosetta.core.scoring.elec.ElecAtom, other : rosetta.core.scoring.elec.ElecAtom) -> bool   equality operator for shared-prefix detection __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.elec.ElecAtom) -> NoneType   2. __init__(self : rosetta.core.scoring.elec.ElecAtom, res : rosetta.core.conformation.Residue, atom_index : int) -> 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.elec.ElecAtom) -> str assign(...) from builtins.PyCapsule assign(self : rosetta.core.scoring.elec.ElecAtom,  : rosetta.core.scoring.elec.ElecAtom) -> rosetta.core.scoring.elec.ElecAtom atom_type(...) from builtins.PyCapsule atom_type(*args, **kwargs) Overloaded function.   1. atom_type(rosetta.core.scoring.elec.ElecAtom) -> int   deprecated!   2. atom_type(self : rosetta.core.scoring.elec.ElecAtom, setting : int) -> NoneType   deprecated! charge(...) from builtins.PyCapsule charge(*args, **kwargs) Overloaded function.   1. charge(rosetta.core.scoring.elec.ElecAtom) -> float   2. charge(self : rosetta.core.scoring.elec.ElecAtom, setting : float) -> NoneType is_hydrogen(...) from builtins.PyCapsule is_hydrogen(*args, **kwargs) Overloaded function.   1. is_hydrogen(rosetta.core.scoring.elec.ElecAtom) -> bool   property required by RotamerTrie class   2. is_hydrogen(self : rosetta.core.scoring.elec.ElecAtom, setting : bool) -> NoneType   setter method for data required by RotamerTrie class isbb(...) from builtins.PyCapsule isbb(rosetta.core.scoring.elec.ElecAtom) -> bool print(...) from builtins.PyCapsule print(rosetta.core.scoring.elec.ElecAtom) -> NoneType   send a description of the atom to standard out Methods inherited from rosetta.core.conformation.Atom: mm_type(...) from builtins.PyCapsule mm_type(*args, **kwargs) Overloaded function.   1. mm_type(self : rosetta.core.conformation.Atom, mm_type_in : int) -> NoneType   set the mm atom type number   2. mm_type(rosetta.core.conformation.Atom) -> int   get the mm atom type number type(...) from builtins.PyCapsule type(*args, **kwargs) Overloaded function.   1. type(self : rosetta.core.conformation.Atom, type_in : int) -> NoneType   set the atom type number   2. type(rosetta.core.conformation.Atom) -> int   Returns the AtomType number xyz(...) from builtins.PyCapsule xyz(*args, **kwargs) Overloaded function.   1. xyz(rosetta.core.conformation.Atom) -> rosetta.numeric.xyzVector_double_t   Returns the atom coordinates as an xyzVector   2. xyz(self : rosetta.core.conformation.Atom, xyz_in : rosetta.numeric.xyzVector_double_t) -> NoneType   Sets the atom coordinates using an xyzVector   class ElecGroup(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.scoring.elec.ElecGroup) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. Data descriptors defined here: atms comatms n_acceptor n_donor qeps   class FAElecContextData(rosetta.basic.datacache.CacheableData)       Method resolution order: FAElecContextData 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.elec.FAElecContextData) -> 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.elec.FAElecContextData,  : rosetta.core.scoring.elec.FAElecContextData) -> rosetta.core.scoring.elec.FAElecContextData boundary_neighs(...) from builtins.PyCapsule boundary_neighs(self : rosetta.core.scoring.elec.FAElecContextData, i : int) -> rosetta.utility.vector1_unsigned_long clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.elec.FAElecContextData) -> rosetta.basic.datacache.CacheableData dw_dr(...) from builtins.PyCapsule dw_dr(self : rosetta.core.scoring.elec.FAElecContextData, i : int) -> rosetta.numeric.xyzVector_double_t get_boundary_neighs(...) from builtins.PyCapsule get_boundary_neighs(self : rosetta.core.scoring.elec.FAElecContextData, i : int) -> rosetta.utility.vector1_unsigned_long get_dw_dr(...) from builtins.PyCapsule get_dw_dr(self : rosetta.core.scoring.elec.FAElecContextData, i : int) -> rosetta.numeric.xyzVector_double_t get_n(...) from builtins.PyCapsule get_n(self : rosetta.core.scoring.elec.FAElecContextData, i : int) -> float initialize(...) from builtins.PyCapsule initialize(self : rosetta.core.scoring.elec.FAElecContextData, nres : int) -> NoneType n(...) from builtins.PyCapsule n(self : rosetta.core.scoring.elec.FAElecContextData, i : int) -> float 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 FA_ElecEnergy(rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy)       Method resolution order: FA_ElecEnergy rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy rosetta.core.scoring.methods.TwoBodyEnergy rosetta.core.scoring.methods.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.elec.FA_ElecEnergy) -> 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.elec.FA_ElecEnergy,  : rosetta.core.scoring.elec.FA_ElecEnergy) -> rosetta.core.scoring.elec.FA_ElecEnergy atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.elec.FA_ElecEnergy) -> float backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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.elec.FA_ElecEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.elec.FA_ElecEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.elec.FA_ElecEnergy) -> bool elec_weight(...) from builtins.PyCapsule elec_weight(*args, **kwargs) Overloaded function.   1. elec_weight(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1isbb : bool, at2isbb : bool) -> float   This has to go   2. elec_weight(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1isbb : bool, at2isbb : bool, wts : rosetta.core.scoring.elec.weight_triple) -> float eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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   Evaluate the derivative vectors for a particular atom in a given  (asymmetric) pose when nblist_autoupdate is being used.  nblist_autoupdate  cannot be used with symmetric poses, in rtmin, or in minpack. eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy,  : 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.elec.FA_ElecEnergy, 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 atom derivative f1/f2 vectors for all atoms on rsd1  in response to the atoms on rsd2, and all the atoms on rsd2 as they  in response to the atoms on rsd1.  This method is used with the  MinimizationGraph and when nblist_autoupdate is not in use. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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.elec.FA_ElecEnergy, 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 finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : 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.elec.FA_ElecEnergy,  : int,  : int,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   Interface function for class NeighborList.   2. get_count_pair_function(self : rosetta.core.scoring.elec.FA_ElecEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue) -> rosetta.core.scoring.etable.count_pair.CountPairFunction get_countpair_representative_atom(...) from builtins.PyCapsule get_countpair_representative_atom(self : rosetta.core.scoring.elec.FA_ElecEnergy, restype : rosetta.core.chemical.ResidueType, atm_i : int) -> int get_cp_tables(...) from builtins.PyCapsule get_cp_tables(rosetta.core.scoring.elec.FA_ElecEnergy) -> NoneType get_intrares_countpair(...) from builtins.PyCapsule get_intrares_countpair(self : rosetta.core.scoring.elec.FA_ElecEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   Interface function for class NeighborList. heavyatom_heavyatom_energy(...) from builtins.PyCapsule heavyatom_heavyatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom, d2 : float,  : int) -> float heavyatom_hydrogenatom_energy(...) from builtins.PyCapsule heavyatom_hydrogenatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float hydrogen_interaction_cutoff(...) from builtins.PyCapsule hydrogen_interaction_cutoff(rosetta.core.scoring.elec.FA_ElecEnergy) -> float   How close two heavy atoms have to be such that their hydrogen atoms might interact hydrogen_interaction_cutoff2(...) from builtins.PyCapsule hydrogen_interaction_cutoff2(rosetta.core.scoring.elec.FA_ElecEnergy) -> float   How close two heavy atoms have to be such that their hydrogen atoms might interact, squared. hydrogenatom_heavyatom_energy(...) from builtins.PyCapsule hydrogenatom_heavyatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float hydrogenatom_hydrogenatom_energy(...) from builtins.PyCapsule hydrogenatom_hydrogenatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.elec.FA_ElecEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType initialize(...) from builtins.PyCapsule initialize(rosetta.core.scoring.elec.FA_ElecEnergy) -> NoneType   Initilize constants. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose) -> bool   Returns true if we're using neighborlist-autoupdate prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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.elec.FA_ElecEnergy, 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 setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   stashes nblist if use_nblist is true setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose, resid : int) -> NoneType use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.elec.FA_ElecEnergy) -> bool Methods inherited from 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 rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy: 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 rosetta.core.scoring.methods.TwoBodyEnergy: 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. 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 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 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". 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 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. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class FA_ElecEnergyAroAll(FA_ElecEnergy)       Method resolution order: FA_ElecEnergyAroAll FA_ElecEnergy rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy rosetta.core.scoring.methods.TwoBodyEnergy rosetta.core.scoring.methods.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.elec.FA_ElecEnergyAroAll) -> 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.elec.FA_ElecEnergyAroAll,  : rosetta.core.scoring.elec.FA_ElecEnergyAroAll) -> rosetta.core.scoring.elec.FA_ElecEnergyAroAll clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.elec.FA_ElecEnergyAroAll) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAll,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAll, 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_atom_derivative_aro_aro(...) from builtins.PyCapsule eval_atom_derivative_aro_aro(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAll, rsd1 : rosetta.core.conformation.Residue, i : int, rsd2 : rosetta.core.conformation.Residue, 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.elec.FA_ElecEnergyAroAll,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAll, 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.elec.FA_ElecEnergyAroAll, 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 indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAll, 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.elec.FA_ElecEnergyAroAll,  : rosetta.core.pose.Pose) -> bool   Returns "true" because this energy method has not been updated to  use the new derivative evaluation machinery.  Note that this class requires  the definition of this method because it's parent class, FA_ElecEnergy,  HAS been updated to use the new derivative evaluation machinery, and,  if this class did not return "true", it would be asked to evaluate derivatives  in ways it cannot yet evaluate them in. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAll, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType   overrides parent class implementation which would have  created several tries residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAll, 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_aro_aro(...) from builtins.PyCapsule residue_pair_energy_aro_aro(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAll, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, emap : rosetta.core.scoring.EMapVector) -> float setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAll, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAll, 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.elec.FA_ElecEnergyAroAll, 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.elec.FA_ElecEnergyAroAll, pose : rosetta.core.pose.Pose, resid : int) -> NoneType   overrides parent class implementation which would have  updated a trie version(...) from builtins.PyCapsule version(rosetta.core.scoring.elec.FA_ElecEnergyAroAll) -> int Methods inherited from FA_ElecEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.elec.FA_ElecEnergy) -> float backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.elec.FA_ElecEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.elec.FA_ElecEnergy) -> bool elec_weight(...) from builtins.PyCapsule elec_weight(*args, **kwargs) Overloaded function.   1. elec_weight(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1isbb : bool, at2isbb : bool) -> float   This has to go   2. elec_weight(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1isbb : bool, at2isbb : bool, wts : rosetta.core.scoring.elec.weight_triple) -> float eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 atom derivative f1/f2 vectors for all atoms on rsd1  in response to the atoms on rsd2, and all the atoms on rsd2 as they  in response to the atoms on rsd1.  This method is used with the  MinimizationGraph and when nblist_autoupdate is not in use. finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : 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.elec.FA_ElecEnergy,  : int,  : int,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   Interface function for class NeighborList.   2. get_count_pair_function(self : rosetta.core.scoring.elec.FA_ElecEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue) -> rosetta.core.scoring.etable.count_pair.CountPairFunction get_countpair_representative_atom(...) from builtins.PyCapsule get_countpair_representative_atom(self : rosetta.core.scoring.elec.FA_ElecEnergy, restype : rosetta.core.chemical.ResidueType, atm_i : int) -> int get_cp_tables(...) from builtins.PyCapsule get_cp_tables(rosetta.core.scoring.elec.FA_ElecEnergy) -> NoneType get_intrares_countpair(...) from builtins.PyCapsule get_intrares_countpair(self : rosetta.core.scoring.elec.FA_ElecEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   Interface function for class NeighborList. heavyatom_heavyatom_energy(...) from builtins.PyCapsule heavyatom_heavyatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom, d2 : float,  : int) -> float heavyatom_hydrogenatom_energy(...) from builtins.PyCapsule heavyatom_hydrogenatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float hydrogen_interaction_cutoff(...) from builtins.PyCapsule hydrogen_interaction_cutoff(rosetta.core.scoring.elec.FA_ElecEnergy) -> float   How close two heavy atoms have to be such that their hydrogen atoms might interact hydrogen_interaction_cutoff2(...) from builtins.PyCapsule hydrogen_interaction_cutoff2(rosetta.core.scoring.elec.FA_ElecEnergy) -> float   How close two heavy atoms have to be such that their hydrogen atoms might interact, squared. hydrogenatom_heavyatom_energy(...) from builtins.PyCapsule hydrogenatom_heavyatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float hydrogenatom_hydrogenatom_energy(...) from builtins.PyCapsule hydrogenatom_hydrogenatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float initialize(...) from builtins.PyCapsule initialize(rosetta.core.scoring.elec.FA_ElecEnergy) -> NoneType   Initilize constants. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   stashes nblist if use_nblist is true setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.elec.FA_ElecEnergy) -> bool Methods inherited from 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 rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy: 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 rosetta.core.scoring.methods.TwoBodyEnergy: 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. 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 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 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". 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 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.   class FA_ElecEnergyAroAllCreator(rosetta.core.scoring.methods.EnergyMethodCreator)       Method resolution order: FA_ElecEnergyAroAllCreator rosetta.core.scoring.methods.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.elec.FA_ElecEnergyAroAllCreator,  : rosetta.core.scoring.elec.FA_ElecEnergyAroAllCreator) -> rosetta.core.scoring.elec.FA_ElecEnergyAroAllCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAllCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new FA_ElecEnergyAroAll score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.elec.FA_ElecEnergyAroAllCreator) -> 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_ElecEnergyAroAro(FA_ElecEnergy)       Method resolution order: FA_ElecEnergyAroAro FA_ElecEnergy rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy rosetta.core.scoring.methods.TwoBodyEnergy rosetta.core.scoring.methods.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.elec.FA_ElecEnergyAroAro) -> 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.elec.FA_ElecEnergyAroAro,  : rosetta.core.scoring.elec.FA_ElecEnergyAroAro) -> rosetta.core.scoring.elec.FA_ElecEnergyAroAro clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.elec.FA_ElecEnergyAroAro) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAro,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAro, 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_atom_derivative_aro_aro(...) from builtins.PyCapsule eval_atom_derivative_aro_aro(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAro, rsd1 : rosetta.core.conformation.Residue, i : int, rsd2 : rosetta.core.conformation.Residue, 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.elec.FA_ElecEnergyAroAro,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAro, 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.elec.FA_ElecEnergyAroAro, 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 indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAro, 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.elec.FA_ElecEnergyAroAro,  : rosetta.core.pose.Pose) -> bool   Returns "true" because this energy method has not been updated to  use the new derivative evaluation machinery.  Note that this class requires  the definition of this method because it's parent class, FA_ElecEnergy,  HAS been updated to use the new derivative evaluation machinery, and,  if this class did not return "true", it would be asked to evaluate derivatives  in ways it cannot yet evaluate them in. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAro, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType   overrides parent class implementation which would have  created several tries residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAro, 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_aro_aro(...) from builtins.PyCapsule residue_pair_energy_aro_aro(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAro, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, emap : rosetta.core.scoring.EMapVector) -> float setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAro, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAro, 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.elec.FA_ElecEnergyAroAro, 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.elec.FA_ElecEnergyAroAro, pose : rosetta.core.pose.Pose, resid : int) -> NoneType   overrides parent class implementation which would have  updated a trie version(...) from builtins.PyCapsule version(rosetta.core.scoring.elec.FA_ElecEnergyAroAro) -> int Methods inherited from FA_ElecEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.elec.FA_ElecEnergy) -> float backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.elec.FA_ElecEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.elec.FA_ElecEnergy) -> bool elec_weight(...) from builtins.PyCapsule elec_weight(*args, **kwargs) Overloaded function.   1. elec_weight(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1isbb : bool, at2isbb : bool) -> float   This has to go   2. elec_weight(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1isbb : bool, at2isbb : bool, wts : rosetta.core.scoring.elec.weight_triple) -> float eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 atom derivative f1/f2 vectors for all atoms on rsd1  in response to the atoms on rsd2, and all the atoms on rsd2 as they  in response to the atoms on rsd1.  This method is used with the  MinimizationGraph and when nblist_autoupdate is not in use. finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : 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.elec.FA_ElecEnergy,  : int,  : int,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   Interface function for class NeighborList.   2. get_count_pair_function(self : rosetta.core.scoring.elec.FA_ElecEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue) -> rosetta.core.scoring.etable.count_pair.CountPairFunction get_countpair_representative_atom(...) from builtins.PyCapsule get_countpair_representative_atom(self : rosetta.core.scoring.elec.FA_ElecEnergy, restype : rosetta.core.chemical.ResidueType, atm_i : int) -> int get_cp_tables(...) from builtins.PyCapsule get_cp_tables(rosetta.core.scoring.elec.FA_ElecEnergy) -> NoneType get_intrares_countpair(...) from builtins.PyCapsule get_intrares_countpair(self : rosetta.core.scoring.elec.FA_ElecEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   Interface function for class NeighborList. heavyatom_heavyatom_energy(...) from builtins.PyCapsule heavyatom_heavyatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom, d2 : float,  : int) -> float heavyatom_hydrogenatom_energy(...) from builtins.PyCapsule heavyatom_hydrogenatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float hydrogen_interaction_cutoff(...) from builtins.PyCapsule hydrogen_interaction_cutoff(rosetta.core.scoring.elec.FA_ElecEnergy) -> float   How close two heavy atoms have to be such that their hydrogen atoms might interact hydrogen_interaction_cutoff2(...) from builtins.PyCapsule hydrogen_interaction_cutoff2(rosetta.core.scoring.elec.FA_ElecEnergy) -> float   How close two heavy atoms have to be such that their hydrogen atoms might interact, squared. hydrogenatom_heavyatom_energy(...) from builtins.PyCapsule hydrogenatom_heavyatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float hydrogenatom_hydrogenatom_energy(...) from builtins.PyCapsule hydrogenatom_hydrogenatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float initialize(...) from builtins.PyCapsule initialize(rosetta.core.scoring.elec.FA_ElecEnergy) -> NoneType   Initilize constants. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   stashes nblist if use_nblist is true setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.elec.FA_ElecEnergy) -> bool Methods inherited from 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 rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy: 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 rosetta.core.scoring.methods.TwoBodyEnergy: 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. 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 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 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". 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 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.   class FA_ElecEnergyAroAroCreator(rosetta.core.scoring.methods.EnergyMethodCreator)       Method resolution order: FA_ElecEnergyAroAroCreator rosetta.core.scoring.methods.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.elec.FA_ElecEnergyAroAroCreator,  : rosetta.core.scoring.elec.FA_ElecEnergyAroAroCreator) -> rosetta.core.scoring.elec.FA_ElecEnergyAroAroCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.elec.FA_ElecEnergyAroAroCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new FA_ElecEnergyAroAro score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.elec.FA_ElecEnergyAroAroCreator) -> 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_ElecEnergyCreator(rosetta.core.scoring.methods.EnergyMethodCreator)       Method resolution order: FA_ElecEnergyCreator rosetta.core.scoring.methods.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.elec.FA_ElecEnergyCreator,  : rosetta.core.scoring.elec.FA_ElecEnergyCreator) -> rosetta.core.scoring.elec.FA_ElecEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.elec.FA_ElecEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new FA_ElecEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.elec.FA_ElecEnergyCreator) -> 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_GrpElecEnergy(rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy)       Method resolution order: FA_GrpElecEnergy rosetta.core.scoring.methods.ContextDependentTwoBodyEnergy rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy rosetta.core.scoring.methods.TwoBodyEnergy rosetta.core.scoring.methods.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.elec.FA_GrpElecEnergy) -> 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.elec.FA_GrpElecEnergy) -> float clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.elec.FA_GrpElecEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.elec.FA_GrpElecEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.elec.FA_GrpElecEnergy,  : rosetta.core.id.AtomID,  : rosetta.core.pose.Pose,  : ObjexxFCL::FArray1D<int>,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector,  : rosetta.numeric.xyzVector_double_t,  : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the derivative vectors for a particular atom in a given  (asymmetric) pose when nblist_autoupdate is being used.  nblist_autoupdate  cannot be used with symmetric poses, in rtmin, or in minpack. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, rsd : rosetta.core.conformation.Residue,  : 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.elec.FA_GrpElecEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : 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.elec.FA_GrpElecEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData,  : 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 atom derivative f1/f2 vectors for all atoms on rsd1  in response to the atoms on rsd2, and all the atoms on rsd2 as they  in response to the atoms on rsd1.  This method is used with the  MinimizationGraph and when nblist_autoupdate is not in use. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose,  : 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.elec.FA_GrpElecEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.elec.FA_GrpElecEnergy,  : 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.elec.FA_GrpElecEnergy,  : int,  : int,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   Interface function for class NeighborList.   2. get_count_pair_function(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, 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.elec.FA_GrpElecEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   Interface function for class NeighborList. indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType initialize(...) from builtins.PyCapsule initialize(rosetta.core.scoring.elec.FA_GrpElecEnergy) -> NoneType   Initilize constants. minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, pose : rosetta.core.pose.Pose) -> bool   Returns true if we're using neighborlist-autoupdate prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.elec.FA_GrpElecEnergy,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, 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.elec.FA_GrpElecEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, pose : rosetta.core.pose.Pose, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   stashes nblist if use_nblist is true setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, 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,  : rosetta.core.scoring.ResPairMinimizationData) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.elec.FA_GrpElecEnergy, 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.elec.FA_GrpElecEnergy, pose : rosetta.core.pose.Pose, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.elec.FA_GrpElecEnergy,  : rosetta.core.pose.Pose,  : int) -> NoneType use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.elec.FA_GrpElecEnergy) -> bool Methods inherited from rosetta.core.scoring.methods.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 rosetta.core.scoring.methods.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 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_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_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. 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 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". 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 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. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class FA_GrpElecEnergyCreator(rosetta.core.scoring.methods.EnergyMethodCreator)       Method resolution order: FA_GrpElecEnergyCreator rosetta.core.scoring.methods.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.elec.FA_GrpElecEnergyCreator,  : rosetta.core.scoring.elec.FA_GrpElecEnergyCreator) -> rosetta.core.scoring.elec.FA_GrpElecEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.elec.FA_GrpElecEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new FA_ElecEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.elec.FA_GrpElecEnergyCreator) -> 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 GroupElec(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.scoring.elec.GroupElec, src : rosetta.core.scoring.elec.GroupElec) -> NoneType   2. __init__(self : rosetta.core.scoring.elec.GroupElec, 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. eval_respair_group_coulomb(...) from builtins.PyCapsule eval_respair_group_coulomb(self : rosetta.core.scoring.elec.GroupElec, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue) -> float eval_respair_group_derivatives(...) from builtins.PyCapsule eval_respair_group_derivatives(self : rosetta.core.scoring.elec.GroupElec, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, elec_weight : float, Erespair : float) -> NoneType initialize(...) from builtins.PyCapsule initialize(self : rosetta.core.scoring.elec.GroupElec, coulomb : rosetta.core.scoring.etable.coulomb.Coulomb) -> NoneType   class RNA_FA_ElecEnergy(FA_ElecEnergy)       Method resolution order: RNA_FA_ElecEnergy FA_ElecEnergy rosetta.core.scoring.methods.ContextIndependentTwoBodyEnergy rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy rosetta.core.scoring.methods.TwoBodyEnergy rosetta.core.scoring.methods.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.elec.RNA_FA_ElecEnergy) -> 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.elec.RNA_FA_ElecEnergy,  : rosetta.core.scoring.elec.RNA_FA_ElecEnergy) -> rosetta.core.scoring.elec.RNA_FA_ElecEnergy backbone_backbone_energy(...) from builtins.PyCapsule backbone_backbone_energy(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy, 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.elec.RNA_FA_ElecEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy,  : rosetta.core.scoring.EMapVector) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy, 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_atom_derivative_RNA(...) from builtins.PyCapsule eval_atom_derivative_RNA(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy, rsd1 : rosetta.core.conformation.Residue, i : int, rsd2 : rosetta.core.conformation.Residue, 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.elec.RNA_FA_ElecEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy, 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.elec.RNA_FA_ElecEnergy, 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 indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy, 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.elec.RNA_FA_ElecEnergy,  : rosetta.core.pose.Pose) -> bool   Returns "true" because this energy method has not been updated to  use the new derivative evaluation machinery.  Note that this class requires  the definition of this method because it's parent class, FA_ElecEnergy,  HAS been updated to use the new derivative evaluation machinery, and,  if this class did not return "true", it would be asked to evaluate derivatives  in ways it cannot yet evaluate them in. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType   overrides parent class implementation which would have  created several tries residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy, 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   ////////////////////////////////////////////////////////////////////////// rna_fa_elec_one_way(...) from builtins.PyCapsule rna_fa_elec_one_way(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.conformation.Residue,  : rosetta.RNAAtomType,  : rosetta.RNAAtomType) -> float setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergy, 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.elec.RNA_FA_ElecEnergy, 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.elec.RNA_FA_ElecEnergy, pose : rosetta.core.pose.Pose, resid : int) -> NoneType   overrides parent class implementation which would have  updated a trie use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.elec.RNA_FA_ElecEnergy) -> bool   Jan 10, 2012. Parin Sripakdeevon (sripakpa.edu)  Returns "false" to overwrite the behavior in the parent class (FA_ElecEnergy)! version(...) from builtins.PyCapsule version(rosetta.core.scoring.elec.RNA_FA_ElecEnergy) -> int Methods inherited from FA_ElecEnergy: atomic_interaction_cutoff(...) from builtins.PyCapsule atomic_interaction_cutoff(rosetta.core.scoring.elec.FA_ElecEnergy) -> float backbone_sidechain_energy(...) from builtins.PyCapsule backbone_sidechain_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.elec.FA_ElecEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool divides_backbone_and_sidechain_energetics(...) from builtins.PyCapsule divides_backbone_and_sidechain_energetics(rosetta.core.scoring.elec.FA_ElecEnergy) -> bool elec_weight(...) from builtins.PyCapsule elec_weight(*args, **kwargs) Overloaded function.   1. elec_weight(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1isbb : bool, at2isbb : bool) -> float   This has to go   2. elec_weight(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1isbb : bool, at2isbb : bool, wts : rosetta.core.scoring.elec.weight_triple) -> float eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 atom derivative f1/f2 vectors for all atoms on rsd1  in response to the atoms on rsd2, and all the atoms on rsd2 as they  in response to the atoms on rsd1.  This method is used with the  MinimizationGraph and when nblist_autoupdate is not in use. finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : 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.elec.FA_ElecEnergy,  : int,  : int,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   Interface function for class NeighborList.   2. get_count_pair_function(self : rosetta.core.scoring.elec.FA_ElecEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue) -> rosetta.core.scoring.etable.count_pair.CountPairFunction get_countpair_representative_atom(...) from builtins.PyCapsule get_countpair_representative_atom(self : rosetta.core.scoring.elec.FA_ElecEnergy, restype : rosetta.core.chemical.ResidueType, atm_i : int) -> int get_cp_tables(...) from builtins.PyCapsule get_cp_tables(rosetta.core.scoring.elec.FA_ElecEnergy) -> NoneType get_intrares_countpair(...) from builtins.PyCapsule get_intrares_countpair(self : rosetta.core.scoring.elec.FA_ElecEnergy,  : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.etable.count_pair.CountPairFunction   Interface function for class NeighborList. heavyatom_heavyatom_energy(...) from builtins.PyCapsule heavyatom_heavyatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom, d2 : float,  : int) -> float heavyatom_hydrogenatom_energy(...) from builtins.PyCapsule heavyatom_hydrogenatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float hydrogen_interaction_cutoff(...) from builtins.PyCapsule hydrogen_interaction_cutoff(rosetta.core.scoring.elec.FA_ElecEnergy) -> float   How close two heavy atoms have to be such that their hydrogen atoms might interact hydrogen_interaction_cutoff2(...) from builtins.PyCapsule hydrogen_interaction_cutoff2(rosetta.core.scoring.elec.FA_ElecEnergy) -> float   How close two heavy atoms have to be such that their hydrogen atoms might interact, squared. hydrogenatom_heavyatom_energy(...) from builtins.PyCapsule hydrogenatom_heavyatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float hydrogenatom_hydrogenatom_energy(...) from builtins.PyCapsule hydrogenatom_hydrogenatom_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, at1 : rosetta.core.scoring.elec.ElecAtom, at2 : rosetta.core.scoring.elec.ElecAtom,  : int) -> float initialize(...) from builtins.PyCapsule initialize(rosetta.core.scoring.elec.FA_ElecEnergy) -> NoneType   Initilize constants. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.elec.FA_ElecEnergy, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_map : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   stashes nblist if use_nblist is true setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.elec.FA_ElecEnergy, 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 Methods inherited from 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 rosetta.core.scoring.methods.ShortRangeTwoBodyEnergy: 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 rosetta.core.scoring.methods.TwoBodyEnergy: 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. 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 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 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". 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 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.   class RNA_FA_ElecEnergyCreator(rosetta.core.scoring.methods.EnergyMethodCreator)       Method resolution order: RNA_FA_ElecEnergyCreator rosetta.core.scoring.methods.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.elec.RNA_FA_ElecEnergyCreator,  : rosetta.core.scoring.elec.RNA_FA_ElecEnergyCreator) -> rosetta.core.scoring.elec.RNA_FA_ElecEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.elec.RNA_FA_ElecEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new RNA_FA_ElecEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.elec.RNA_FA_ElecEnergyCreator) -> 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 weight_triple(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.scoring.elec.weight_triple) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. Data descriptors defined here: wbb_bb_ wbb_sc_ wsc_sc_

Functions
		read_cp_tables_from_db(...) method of builtins.PyCapsule instance read_cp_tables_from_db(filename : str) -> rosetta.std.map_std_string_std_map_std_string_std_string_std_less_std_string_std_allocator_std_pair_const_std_string_std_string_t   Read the CP tables from the database and return an owning pointer to the  new object created in memory.      Called by the ScoringManager to allow these data to be read in once and  only once.