Bindings for core::scoring::electron_density namespace

Classes
		builtins.object ElectronDensity KromerMann OneGaussianScattering poseCoord rosetta.basic.resource_manager.ResourceLoader(builtins.object) ElectronDensityLoader rosetta.basic.resource_manager.ResourceLoaderCreator(builtins.object) ElectronDensityLoaderCreator rosetta.basic.resource_manager.ResourceOptions(builtins.object) ElectronDensityOptions rosetta.basic.resource_manager.ResourceOptionsCreator(builtins.object) ElectronDensityOptionsCreator rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy(rosetta.core.scoring.methods.LongRangeTwoBodyEnergy) ElecDensAllAtomCenEnergy ElecDensCenEnergy rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy(rosetta.core.scoring.methods.LongRangeTwoBodyEnergy) ElecDensEnergy FastDensEnergy rosetta.core.scoring.methods.EnergyMethodCreator(builtins.object) ElecDensAllAtomCenEnergyCreator ElecDensCenEnergyCreator ElecDensEnergyCreator FastDensEnergyCreator   class ElecDensAllAtomCenEnergy(rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy)       Method resolution order: ElecDensAllAtomCenEnergy rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy rosetta.core.scoring.methods.LongRangeTwoBodyEnergy 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__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy) -> 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.electron_density.ElecDensAllAtomCenEnergy,  : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy) -> rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose,  : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   called during gradient-based minimization inside dfunc eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue constraint energy for a given residue finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   called at the end of energy evaluation indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy,  : rosetta.utility.vector1_bool) -> NoneType long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType   ////////////////////////////////////////////////////////////////////////// residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy, 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 setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy, pose : rosetta.core.pose.Pose, sf : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from 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. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from 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 minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ElecDensAllAtomCenEnergyCreator(rosetta.core.scoring.methods.EnergyMethodCreator)       Method resolution order: ElecDensAllAtomCenEnergyCreator 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.electron_density.ElecDensAllAtomCenEnergyCreator,  : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergyCreator) -> rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ElecDensCenEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.electron_density.ElecDensAllAtomCenEnergyCreator) -> 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 ElecDensCenEnergy(rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy)       Method resolution order: ElecDensCenEnergy rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy rosetta.core.scoring.methods.LongRangeTwoBodyEnergy 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__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.electron_density.ElecDensCenEnergy) -> 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.electron_density.ElecDensCenEnergy,  : rosetta.core.scoring.electron_density.ElecDensCenEnergy) -> rosetta.core.scoring.electron_density.ElecDensCenEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.electron_density.ElecDensCenEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.electron_density.ElecDensCenEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.electron_density.ElecDensCenEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.electron_density.ElecDensCenEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose,  : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   called during gradient-based minimization inside dfunc eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.electron_density.ElecDensCenEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue constraint energy for a given residue finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.electron_density.ElecDensCenEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   called at the end of energy evaluation indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.electron_density.ElecDensCenEnergy,  : rosetta.utility.vector1_bool) -> NoneType long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.electron_density.ElecDensCenEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType   ////////////////////////////////////////////////////////////////////////// residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.electron_density.ElecDensCenEnergy, 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 setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.electron_density.ElecDensCenEnergy, pose : rosetta.core.pose.Pose, sf : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.electron_density.ElecDensCenEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextDependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from 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. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from 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 minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ElecDensCenEnergyCreator(rosetta.core.scoring.methods.EnergyMethodCreator)       Method resolution order: ElecDensCenEnergyCreator 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.electron_density.ElecDensCenEnergyCreator,  : rosetta.core.scoring.electron_density.ElecDensCenEnergyCreator) -> rosetta.core.scoring.electron_density.ElecDensCenEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.electron_density.ElecDensCenEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ElecDensCenEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.electron_density.ElecDensCenEnergyCreator) -> 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 ElecDensEnergy(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy)       Method resolution order: ElecDensEnergy rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy rosetta.core.scoring.methods.LongRangeTwoBodyEnergy 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__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.electron_density.ElecDensEnergy) -> 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.electron_density.ElecDensEnergy,  : rosetta.core.scoring.electron_density.ElecDensEnergy) -> rosetta.core.scoring.electron_density.ElecDensEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.electron_density.ElecDensEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.electron_density.ElecDensEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.electron_density.ElecDensEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.electron_density.ElecDensEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose,  : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   called during gradient-based minimization inside dfunc           F1 and F2 are not zeroed -- contributions from this atom are         just summed in eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.electron_density.ElecDensEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue constraint energy for a given residue finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.electron_density.ElecDensEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType   called at the end of energy evaluation indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.electron_density.ElecDensEnergy,  : rosetta.utility.vector1_bool) -> NoneType long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.electron_density.ElecDensEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType   ////////////////////////////////////////////////////////////////////////// residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.electron_density.ElecDensEnergy, 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 setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.electron_density.ElecDensEnergy, pose : rosetta.core.pose.Pose, sf : rosetta.core.scoring.ScoreFunction) -> NoneType setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.electron_density.ElecDensEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType Methods inherited from rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from 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. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. eval_residue_pair_derivatives(...) from builtins.PyCapsule eval_residue_pair_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivatives for all atoms on rsd1 and rsd2 with respect  to each other and increment the derivatives in atom-derivatives vector1s.  The calling function must guarantee that the r1_atom_derivs vector1 holds at  least as many entries as there are atoms in rsd1, and that the r2_atom_derivs  vector1 holds at least as many entries as there are atoms in rsd2. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from 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 minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated only in the context of the whole Pose, or can it be included  in a decomposed manner for a residue or a set of residue-pairs that are  not part of the Pose that's serving as their context?  The default  method implemented in the base class returns true in order to grandfather  in EnergyMethods that have not had their derivatives changed to take  advantage of the new derivative-evaluation machinery.  Methods that return  "true" will not have their residue-energy(-ext) / residue-pair-energy(-ext)  methods invoked by the ScoreFunction during its traversal of the  MinimizationGraph, and instead will be asked to perform all their work  during finalize_total_energies().  Similarly, they will be expected to  perform all their work during eval_atom_deriv() instead of during the  ScoreFunction's traversal of the MinimizationGraph for derivative evaluation.  IMPORTANT: Methods that return "true" cannot be included in RTMin. prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class ElecDensEnergyCreator(rosetta.core.scoring.methods.EnergyMethodCreator)       Method resolution order: ElecDensEnergyCreator 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.electron_density.ElecDensEnergyCreator,  : rosetta.core.scoring.electron_density.ElecDensEnergyCreator) -> rosetta.core.scoring.electron_density.ElecDensEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.electron_density.ElecDensEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new ElecDensEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.electron_density.ElecDensEnergyCreator) -> 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 ElectronDensity(builtins.object)       Methods defined here: S2(...) from builtins.PyCapsule S2(self : rosetta.core.scoring.electron_density.ElectronDensity, h : int, k : int, l : int) -> float __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.electron_density.ElectronDensity) -> NoneType   2. __init__(self : rosetta.core.scoring.electron_density.ElectronDensity, poses : rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t, reso : float, apix : float) -> NoneType   3. __init__(self : rosetta.core.scoring.electron_density.ElectronDensity,  : rosetta.core.scoring.electron_density.ElectronDensity) -> 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.electron_density.ElectronDensity,  : rosetta.core.scoring.electron_density.ElectronDensity) -> rosetta.core.scoring.electron_density.ElectronDensity cart2idx(...) from builtins.PyCapsule cart2idx(self : rosetta.core.scoring.electron_density.ElectronDensity, cartX : rosetta.numeric.xyzVector_double_t, idxX : rosetta.numeric.xyzVector_double_t) -> NoneType clearMask(...) from builtins.PyCapsule clearMask(rosetta.core.scoring.electron_density.ElectronDensity) -> NoneType   reset scoring to use all residues clear_dCCdx_res_cache(...) from builtins.PyCapsule clear_dCCdx_res_cache(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose) -> NoneType   Resets the counters used for derivative computation in    sliding-window/fast scoring computeStats(...) from builtins.PyCapsule computeStats(rosetta.core.scoring.electron_density.ElectronDensity) -> NoneType compute_symm_rotations(...) from builtins.PyCapsule compute_symm_rotations(*args, **kwargs) Overloaded function.   1. compute_symm_rotations(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose) -> NoneType   Computes the symmatric rotation matrices   2. compute_symm_rotations(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose, symmInfo : rosetta.core.conformation.symmetry.SymmetryInfo) -> NoneType   Computes the symmatric rotation matrices dCCdB_fastRes(...) from builtins.PyCapsule dCCdB_fastRes(self : rosetta.core.scoring.electron_density.ElectronDensity, atmid : int, resid : int, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose) -> float   Gradient of CC w.r.t B factors dCCdBs(...) from builtins.PyCapsule dCCdBs(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose, dE_dvars : rosetta.utility.vector1_double, maskC : ObjexxFCL::FArray3D<double>) -> NoneType   calculate all gradients of CC w.r.t B factors (slow more precise version) dCCdx_PointFast(...) from builtins.PyCapsule dCCdx_PointFast(self : rosetta.core.scoring.electron_density.ElectronDensity, X : rosetta.numeric.xyzVector_double_t, dCCdx : rosetta.numeric.xyzVector_double_t) -> NoneType   access fastdens scoring for a single point dCCdx_aacen(...) from builtins.PyCapsule dCCdx_aacen(self : rosetta.core.scoring.electron_density.ElectronDensity, atmid : int, resid : int, X : rosetta.numeric.xyzVector_double_t, pose : rosetta.core.pose.Pose, gradX : rosetta.numeric.xyzVector_double_t) -> NoneType   Return the gradient of whole-structure-CC w.r.t. atom X's movement  non-sliding-window analogue of dCCdx dCCdx_cen(...) from builtins.PyCapsule dCCdx_cen(self : rosetta.core.scoring.electron_density.ElectronDensity, resid : int, X : rosetta.numeric.xyzVector_double_t, pose : rosetta.core.pose.Pose, gradX : rosetta.numeric.xyzVector_double_t) -> NoneType   Return the gradient of CC w.r.t. res X's CA's movement  Centroid-mode analogue of dCCdx dCCdx_fastRes(...) from builtins.PyCapsule dCCdx_fastRes(self : rosetta.core.scoring.electron_density.ElectronDensity, atmid : int, resid : int, X : rosetta.numeric.xyzVector_double_t, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, gradX : rosetta.numeric.xyzVector_double_t) -> NoneType   Return the gradient of "fast CC" w.r.t. atom X's movement  Uses information stored from the previous call to matchRes with this resid dCCdx_res(...) from builtins.PyCapsule dCCdx_res(self : rosetta.core.scoring.electron_density.ElectronDensity, atmid : int, resid : int, X : rosetta.numeric.xyzVector_double_t, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, gradX : rosetta.numeric.xyzVector_double_t) -> NoneType   Return the gradient of CC w.r.t. atom X's movement  Uses information stored from the previous call to matchRes with this resid dens_grad(...) from builtins.PyCapsule dens_grad(self : rosetta.core.scoring.electron_density.ElectronDensity, idxX : rosetta.numeric.xyzVector_double_t) -> rosetta.numeric.xyzVector_double_t get(...) from builtins.PyCapsule get(*args, **kwargs) Overloaded function.   1. get(self : rosetta.core.scoring.electron_density.ElectronDensity, i : int, j : int, k : int) -> float   get the density at a grid point   2. get(self : rosetta.core.scoring.electron_density.ElectronDensity, X : rosetta.numeric.xyzVector_double_t) -> float   get the interpolated density at a point _in index space_ getAtomMask(...) from builtins.PyCapsule getAtomMask(rosetta.core.scoring.electron_density.ElectronDensity) -> float getCachedScore(...) from builtins.PyCapsule getCachedScore(self : rosetta.core.scoring.electron_density.ElectronDensity, resid : int) -> float   get the precomputed CC (THIS SHOULD LIVE IN POSE DATACACHE!) getEffectiveBfactor(...) from builtins.PyCapsule getEffectiveBfactor(rosetta.core.scoring.electron_density.ElectronDensity) -> float   get the "effective B factor": a global b factor based on map resolution getFSC(...) from builtins.PyCapsule getFSC(*args, **kwargs) Overloaded function.   1. getFSC(self : rosetta.core.scoring.electron_density.ElectronDensity, Frho1 : ObjexxFCL::FArray3D<std::complex<double> >, Frho2 : ObjexxFCL::FArray3D<std::complex<double> >, nbuckets : int, maxreso : float, minreso : float, FSC : rosetta.utility.vector1_double) -> NoneType   Compute map-map FSC   2. getFSC(self : rosetta.core.scoring.electron_density.ElectronDensity, Frho1 : ObjexxFCL::FArray3D<std::complex<double> >, Frho2 : ObjexxFCL::FArray3D<std::complex<double> >, nbuckets : int, maxreso : float, minreso : float, FSC : rosetta.utility.vector1_double, S2_bin : bool) -> NoneType   Compute map-map FSC getGrid(...) from builtins.PyCapsule getGrid(rosetta.core.scoring.electron_density.ElectronDensity) -> rosetta.numeric.xyzVector_int_t getIntensities(...) from builtins.PyCapsule getIntensities(*args, **kwargs) Overloaded function.   1. getIntensities(self : rosetta.core.scoring.electron_density.ElectronDensity, FrhoC : ObjexxFCL::FArray3D<std::complex<double> >, nbuckets : int, maxreso : float, minreso : float, Imap : rosetta.utility.vector1_double) -> NoneType   Compute map intensities, masked by a pose.  Also compute mask intensities   2. getIntensities(self : rosetta.core.scoring.electron_density.ElectronDensity, FrhoC : ObjexxFCL::FArray3D<std::complex<double> >, nbuckets : int, maxreso : float, minreso : float, Imap : rosetta.utility.vector1_double, S2_bin : bool) -> NoneType   Compute map intensities, masked by a pose.  Also compute mask intensities getMax(...) from builtins.PyCapsule getMax(rosetta.core.scoring.electron_density.ElectronDensity) -> float getMean(...) from builtins.PyCapsule getMean(rosetta.core.scoring.electron_density.ElectronDensity) -> float getMin(...) from builtins.PyCapsule getMin(rosetta.core.scoring.electron_density.ElectronDensity) -> float getOrigin(...) from builtins.PyCapsule getOrigin(rosetta.core.scoring.electron_density.ElectronDensity) -> rosetta.numeric.xyzVector_double_t getPhaseError(...) from builtins.PyCapsule getPhaseError(*args, **kwargs) Overloaded function.   1. getPhaseError(self : rosetta.core.scoring.electron_density.ElectronDensity, Frho1 : ObjexxFCL::FArray3D<std::complex<double> >, Frho2 : ObjexxFCL::FArray3D<std::complex<double> >, nbuckets : int, maxreso : float, minreso : float, phaseError : rosetta.utility.vector1_double) -> NoneType   Compute map-map phase error   2. getPhaseError(self : rosetta.core.scoring.electron_density.ElectronDensity, Frho1 : ObjexxFCL::FArray3D<std::complex<double> >, Frho2 : ObjexxFCL::FArray3D<std::complex<double> >, nbuckets : int, maxreso : float, minreso : float, phaseError : rosetta.utility.vector1_double, S2_bin : bool) -> NoneType   Compute map-map phase error getRSCC(...) from builtins.PyCapsule getRSCC(*args, **kwargs) Overloaded function.   1. getRSCC(self : rosetta.core.scoring.electron_density.ElectronDensity, density2 : ObjexxFCL::FArray3D<double>, mask : ObjexxFCL::FArray3D<double>) -> float   Real-space correlation   2. getRSCC(self : rosetta.core.scoring.electron_density.ElectronDensity, rhoC : ObjexxFCL::FArray3D<double>) -> float   Real-space correlation getResolution(...) from builtins.PyCapsule getResolution(rosetta.core.scoring.electron_density.ElectronDensity) -> float getResolutionBins(...) from builtins.PyCapsule getResolutionBins(*args, **kwargs) Overloaded function.   1. getResolutionBins(self : rosetta.core.scoring.electron_density.ElectronDensity, nbuckets : int, maxreso : float, minreso : float,  : rosetta.utility.vector1_double,  : rosetta.utility.vector1_unsigned_long) -> NoneType   get resolution bins   2. getResolutionBins(self : rosetta.core.scoring.electron_density.ElectronDensity, nbuckets : int, maxreso : float, minreso : float,  : rosetta.utility.vector1_double,  : rosetta.utility.vector1_unsigned_long, S2_bin : bool) -> NoneType   get resolution bins getSCscaling(...) from builtins.PyCapsule getSCscaling(rosetta.core.scoring.electron_density.ElectronDensity) -> float getScoreWindowContext(...) from builtins.PyCapsule getScoreWindowContext(rosetta.core.scoring.electron_density.ElectronDensity) -> bool getStdev(...) from builtins.PyCapsule getStdev(rosetta.core.scoring.electron_density.ElectronDensity) -> float getTransform(...) from builtins.PyCapsule getTransform(rosetta.core.scoring.electron_density.ElectronDensity) -> rosetta.numeric.xyzVector_double_t   Get the transformation from indices to Cartesian coords using 'real' origin getWindow(...) from builtins.PyCapsule getWindow(rosetta.core.scoring.electron_density.ElectronDensity) -> int get_R(...) from builtins.PyCapsule get_R(self : rosetta.core.scoring.electron_density.ElectronDensity, subunit : int, R : rosetta.numeric.xyzMatrix_double_t) -> NoneType   gets rotation vactor for subunit 'subunit' in last-scored pose (Rosetta symmetry) get_c2f(...) from builtins.PyCapsule get_c2f(rosetta.core.scoring.electron_density.ElectronDensity) -> rosetta.numeric.xyzMatrix_double_t get_cellDimensions(...) from builtins.PyCapsule get_cellDimensions(rosetta.core.scoring.electron_density.ElectronDensity) -> rosetta.numeric.xyzVector_double_t get_data(...) from builtins.PyCapsule get_data(rosetta.core.scoring.electron_density.ElectronDensity) -> ObjexxFCL::FArray3D<float>   access raw density data get_f2c(...) from builtins.PyCapsule get_f2c(rosetta.core.scoring.electron_density.ElectronDensity) -> rosetta.numeric.xyzMatrix_double_t   get frac<=>cartesian conversion matrices get_symmMap(...) from builtins.PyCapsule get_symmMap(self : rosetta.core.scoring.electron_density.ElectronDensity, vrtid : int, X_map : rosetta.utility.vector1_int, R : rosetta.numeric.xyzMatrix_double_t) -> NoneType   get symmetrized gradients for -score_symm_complex get_voxel_spacing(...) from builtins.PyCapsule get_voxel_spacing(rosetta.core.scoring.electron_density.ElectronDensity) -> rosetta.numeric.xyzVector_double_t   set voxel spacing of the map getsymmOps(...) from builtins.PyCapsule getsymmOps(rosetta.core.scoring.electron_density.ElectronDensity) -> rosetta.utility.vector1_core_kinematics_RT grad(...) from builtins.PyCapsule grad(self : rosetta.core.scoring.electron_density.ElectronDensity, X : rosetta.numeric.xyzVector_double_t) -> rosetta.numeric.xyzVector_double_t   get the interpolated gradient at a point _in index space_ init(...) from builtins.PyCapsule init(rosetta.core.scoring.electron_density.ElectronDensity) -> NoneType   initialize vars from command line options isMapLoaded(...) from builtins.PyCapsule isMapLoaded(rosetta.core.scoring.electron_density.ElectronDensity) -> bool mapSphericalSamples(...) from builtins.PyCapsule mapSphericalSamples(self : rosetta.core.scoring.electron_density.ElectronDensity, mapShellR : ObjexxFCL::FArray3D<double>, nRsteps : int, delR : float, B : int, center : rosetta.numeric.xyzVector_double_t) -> NoneType   resample the map in spherical shells around a pose maskResidues(...) from builtins.PyCapsule maskResidues(*args, **kwargs) Overloaded function.   1. maskResidues(self : rosetta.core.scoring.electron_density.ElectronDensity, scoring_mask : int) -> NoneType   set scoring to use only a subset of residues   2. maskResidues(self : rosetta.core.scoring.electron_density.ElectronDensity, scoring_mask : rosetta.utility.vector1_int) -> NoneType   set scoring to use only a subset of residues matchCentroidPose(...) from builtins.PyCapsule matchCentroidPose(*args, **kwargs) Overloaded function.   1. matchCentroidPose(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose) -> float   Quickly matches a centroid pose into a low-resolution density map    by placing a single Gaussian at each CA   2. matchCentroidPose(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose, symmInfo : rosetta.core.conformation.symmetry.SymmetryInfo) -> float   Quickly matches a centroid pose into a low-resolution density map    by placing a single Gaussian at each CA   3. matchCentroidPose(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose, symmInfo : rosetta.core.conformation.symmetry.SymmetryInfo, cacheCCs : bool) -> float   Quickly matches a centroid pose into a low-resolution density map    by placing a single Gaussian at each CA matchPointFast(...) from builtins.PyCapsule matchPointFast(self : rosetta.core.scoring.electron_density.ElectronDensity, X : rosetta.numeric.xyzVector_double_t) -> float   access fastdens scoring for a single point matchPose(...) from builtins.PyCapsule matchPose(*args, **kwargs) Overloaded function.   1. matchPose(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose) -> float   Match a pose into a medium-resolution density map    by placing a single Gaussian at each atom   2. matchPose(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose, symmInfo : rosetta.core.conformation.symmetry.SymmetryInfo) -> float   Match a pose into a medium-resolution density map    by placing a single Gaussian at each atom   3. matchPose(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose, symmInfo : rosetta.core.conformation.symmetry.SymmetryInfo, cacheCCs : bool) -> float   Match a pose into a medium-resolution density map    by placing a single Gaussian at each atom matchRes(...) from builtins.PyCapsule matchRes(*args, **kwargs) Overloaded function.   1. matchRes(self : rosetta.core.scoring.electron_density.ElectronDensity, resid : int, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose) -> float   Match a residue's conformation to the density map.    Backbone atoms from adjacent residues are also used for scoring.    Returns the correlation coefficient between map and pose    Internally stores per-res CCs, per-atom dCC/dxs   2. matchRes(self : rosetta.core.scoring.electron_density.ElectronDensity, resid : int, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, symmInfo : rosetta.core.conformation.symmetry.SymmetryInfo) -> float   Match a residue's conformation to the density map.    Backbone atoms from adjacent residues are also used for scoring.    Returns the correlation coefficient between map and pose    Internally stores per-res CCs, per-atom dCC/dxs   3. matchRes(self : rosetta.core.scoring.electron_density.ElectronDensity, resid : int, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, symmInfo : rosetta.core.conformation.symmetry.SymmetryInfo, cacheCCs : bool) -> float   Match a residue's conformation to the density map.    Backbone atoms from adjacent residues are also used for scoring.    Returns the correlation coefficient between map and pose    Internally stores per-res CCs, per-atom dCC/dxs matchResFast(...) from builtins.PyCapsule matchResFast(*args, **kwargs) Overloaded function.   1. matchResFast(self : rosetta.core.scoring.electron_density.ElectronDensity, resid : int, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose) -> float   Match a residue's conformation to the density map.     Same as matchRes, but using a fast approximation to the match function   2. matchResFast(self : rosetta.core.scoring.electron_density.ElectronDensity, resid : int, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, symmInfo : rosetta.core.conformation.symmetry.SymmetryInfo) -> float   Match a residue's conformation to the density map.     Same as matchRes, but using a fast approximation to the match function   3. matchResFast(self : rosetta.core.scoring.electron_density.ElectronDensity, resid : int, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, symmInfo : rosetta.core.conformation.symmetry.SymmetryInfo, sc_scale : float) -> float   Match a residue's conformation to the density map.     Same as matchRes, but using a fast approximation to the match function maxNominalRes(...) from builtins.PyCapsule maxNominalRes(rosetta.core.scoring.electron_density.ElectronDensity) -> float   Return the highest possible resolution relection in reciprocal space for the given grid readMRCandResize(...) from builtins.PyCapsule readMRCandResize(*args, **kwargs) Overloaded function.   1. readMRCandResize(self : rosetta.core.scoring.electron_density.ElectronDensity, mapfile : str) -> bool   Load an MRC density map   2. readMRCandResize(self : rosetta.core.scoring.electron_density.ElectronDensity, mapfile : str, reso : float) -> bool   Load an MRC density map   3. readMRCandResize(self : rosetta.core.scoring.electron_density.ElectronDensity, mapfile : str, reso : float, gridSpacing : float) -> bool   Load an MRC density map reciprocalSpaceFilter(...) from builtins.PyCapsule reciprocalSpaceFilter(self : rosetta.core.scoring.electron_density.ElectronDensity, maxreso : float, minreso : float, fadewidth : float) -> NoneType   Filter the map in reciprocal space rescale_fastscoring_temp_bins(...) from builtins.PyCapsule rescale_fastscoring_temp_bins(*args, **kwargs) Overloaded function.   1. rescale_fastscoring_temp_bins(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose) -> NoneType   2. rescale_fastscoring_temp_bins(self : rosetta.core.scoring.electron_density.ElectronDensity, pose : rosetta.core.pose.Pose, init : bool) -> NoneType resize(...) from builtins.PyCapsule resize(self : rosetta.core.scoring.electron_density.ElectronDensity, approxGridSpacing : float) -> NoneType   resize the map via FFT resampling scaleIntensities(...) from builtins.PyCapsule scaleIntensities(*args, **kwargs) Overloaded function.   1. scaleIntensities(self : rosetta.core.scoring.electron_density.ElectronDensity, I_tgt : rosetta.utility.vector1_double, maxreso : float, minreso : float) -> NoneType   Scale map intensities to a target spectum   2. scaleIntensities(self : rosetta.core.scoring.electron_density.ElectronDensity, I_tgt : rosetta.utility.vector1_double, maxreso : float, minreso : float, S2_bin : bool) -> NoneType   Scale map intensities to a target spectum setOrigin(...) from builtins.PyCapsule setOrigin(self : rosetta.core.scoring.electron_density.ElectronDensity, newori : rosetta.numeric.xyzVector_double_t) -> NoneType setSCscaling(...) from builtins.PyCapsule setSCscaling(self : rosetta.core.scoring.electron_density.ElectronDensity, SC_scalingin : float) -> NoneType setScoreWindowContext(...) from builtins.PyCapsule setScoreWindowContext(self : rosetta.core.scoring.electron_density.ElectronDensity, newVal : bool) -> NoneType setWindow(...) from builtins.PyCapsule setWindow(self : rosetta.core.scoring.electron_density.ElectronDensity, window_in : int) -> NoneType set_nres(...) from builtins.PyCapsule set_nres(self : rosetta.core.scoring.electron_density.ElectronDensity, nres : int) -> NoneType   set # of residues set_voxel_spacing(...) from builtins.PyCapsule set_voxel_spacing(*args, **kwargs) Overloaded function.   1. set_voxel_spacing(self : rosetta.core.scoring.electron_density.ElectronDensity, apix : rosetta.numeric.xyzVector_double_t) -> NoneType   set voxel spacing of the map   2. set_voxel_spacing(self : rosetta.core.scoring.electron_density.ElectronDensity, apix : float) -> NoneType   set voxel spacing of the map writeMRC(...) from builtins.PyCapsule writeMRC(self : rosetta.core.scoring.electron_density.ElectronDensity, mapfilestem : str) -> bool   (debugging) Write MRC mapfile   class ElectronDensityLoader(rosetta.basic.resource_manager.ResourceLoader)       Method resolution order: ElectronDensityLoader rosetta.basic.resource_manager.ResourceLoader builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.scoring.electron_density.ElectronDensityLoader) -> 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.electron_density.ElectronDensityLoader,  : rosetta.core.scoring.electron_density.ElectronDensityLoader) -> rosetta.core.scoring.electron_density.ElectronDensityLoader default_options(...) from builtins.PyCapsule default_options(rosetta.core.scoring.electron_density.ElectronDensityLoader) -> rosetta.basic.resource_manager.ResourceOptions   class ElectronDensityLoaderCreator(rosetta.basic.resource_manager.ResourceLoaderCreator)     creator for the ElectronDensityLoader class     Method resolution order: ElectronDensityLoaderCreator rosetta.basic.resource_manager.ResourceLoaderCreator 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.electron_density.ElectronDensityLoaderCreator,  : rosetta.core.scoring.electron_density.ElectronDensityLoaderCreator) -> rosetta.core.scoring.electron_density.ElectronDensityLoaderCreator create_resource_loader(...) from builtins.PyCapsule create_resource_loader(rosetta.core.scoring.electron_density.ElectronDensityLoaderCreator) -> rosetta.basic.resource_manager.ResourceLoader loader_type(...) from builtins.PyCapsule loader_type(rosetta.core.scoring.electron_density.ElectronDensityLoaderCreator) -> str   class ElectronDensityOptions(rosetta.basic.resource_manager.ResourceOptions)       Method resolution order: ElectronDensityOptions rosetta.basic.resource_manager.ResourceOptions builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, name : str) -> NoneType   3. __init__(self : handle, name : str, mapreso : float, grid_spacing : float) -> NoneType   4. __init__(handle, rosetta.core.scoring.electron_density.ElectronDensityOptions) -> 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.electron_density.ElectronDensityOptions,  : rosetta.core.scoring.electron_density.ElectronDensityOptions) -> rosetta.core.scoring.electron_density.ElectronDensityOptions get_grid_spacing(...) from builtins.PyCapsule get_grid_spacing(rosetta.core.scoring.electron_density.ElectronDensityOptions) -> float get_mapreso(...) from builtins.PyCapsule get_mapreso(rosetta.core.scoring.electron_density.ElectronDensityOptions) -> float parse_my_tag(...) from builtins.PyCapsule parse_my_tag(self : rosetta.core.scoring.electron_density.ElectronDensityOptions, tag : rosetta.utility.tag.Tag) -> NoneType set_grid_spacing(...) from builtins.PyCapsule set_grid_spacing(self : rosetta.core.scoring.electron_density.ElectronDensityOptions, grid_spacing : float) -> NoneType set_mapreso(...) from builtins.PyCapsule set_mapreso(self : rosetta.core.scoring.electron_density.ElectronDensityOptions, mapreso : float) -> NoneType type(...) from builtins.PyCapsule type(rosetta.core.scoring.electron_density.ElectronDensityOptions) -> str   The class name for a particular ResourceOptions instance.  This function allows for better error message delivery Methods inherited from rosetta.basic.resource_manager.ResourceOptions: __str__(...) from builtins.PyCapsule __str__(rosetta.basic.resource_manager.ResourceOptions) -> str name(...) from builtins.PyCapsule name(*args, **kwargs) Overloaded function.   1. name(rosetta.basic.resource_manager.ResourceOptions) -> str   A name given to a particular ResourceOptions instance.  This function allows for better error message delivery.   2. name(self : rosetta.basic.resource_manager.ResourceOptions, setting : str) -> NoneType   Set the name for this %ResoureOptions instance.   class ElectronDensityOptionsCreator(rosetta.basic.resource_manager.ResourceOptionsCreator)     creator for the ElectronDensityOptions class     Method resolution order: ElectronDensityOptionsCreator rosetta.basic.resource_manager.ResourceOptionsCreator 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.electron_density.ElectronDensityOptionsCreator,  : rosetta.core.scoring.electron_density.ElectronDensityOptionsCreator) -> rosetta.core.scoring.electron_density.ElectronDensityOptionsCreator create_options(...) from builtins.PyCapsule create_options(rosetta.core.scoring.electron_density.ElectronDensityOptionsCreator) -> rosetta.basic.resource_manager.ResourceOptions options_type(...) from builtins.PyCapsule options_type(rosetta.core.scoring.electron_density.ElectronDensityOptionsCreator) -> str   class FastDensEnergy(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy)       Method resolution order: FastDensEnergy rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy rosetta.core.scoring.methods.LongRangeTwoBodyEnergy rosetta.core.scoring.methods.TwoBodyEnergy rosetta.core.scoring.methods.EnergyMethod builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(self : handle, opts : rosetta.core.scoring.methods.EnergyMethodOptions) -> 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.electron_density.FastDensEnergy,  : rosetta.core.scoring.electron_density.FastDensEnergy) -> rosetta.core.scoring.electron_density.FastDensEnergy clone(...) from builtins.PyCapsule clone(rosetta.core.scoring.electron_density.FastDensEnergy) -> rosetta.core.scoring.methods.EnergyMethod   clone defines_intrares_energy(...) from builtins.PyCapsule defines_intrares_energy(self : rosetta.core.scoring.electron_density.FastDensEnergy,  : rosetta.core.scoring.EMapVector) -> bool defines_residue_pair_energy(...) from builtins.PyCapsule defines_residue_pair_energy(self : rosetta.core.scoring.electron_density.FastDensEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool eval_intrares_energy(...) from builtins.PyCapsule eval_intrares_energy(self : rosetta.core.scoring.electron_density.FastDensEnergy,  : 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.electron_density.FastDensEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue,  : rosetta.core.scoring.ResSingleMinimizationData,  : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData,  : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType finalize_total_energy(...) from builtins.PyCapsule finalize_total_energy(self : rosetta.core.scoring.electron_density.FastDensEnergy,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType indicate_required_context_graphs(...) from builtins.PyCapsule indicate_required_context_graphs(self : rosetta.core.scoring.electron_density.FastDensEnergy,  : rosetta.utility.vector1_bool) -> NoneType long_range_type(...) from builtins.PyCapsule long_range_type(rosetta.core.scoring.electron_density.FastDensEnergy) -> rosetta.core.scoring.methods.LongRangeEnergyType   lr container name minimize_in_whole_structure_context(...) from builtins.PyCapsule minimize_in_whole_structure_context(self : rosetta.core.scoring.electron_density.FastDensEnergy,  : rosetta.core.pose.Pose) -> bool   use the new minimizer interface residue_pair_energy(...) from builtins.PyCapsule residue_pair_energy(self : rosetta.core.scoring.electron_density.FastDensEnergy, 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 setup_for_derivatives(...) from builtins.PyCapsule setup_for_derivatives(self : rosetta.core.scoring.electron_density.FastDensEnergy, pose : rosetta.core.pose.Pose, sf : rosetta.core.scoring.ScoreFunction) -> NoneType   derivatives setup_for_scoring(...) from builtins.PyCapsule setup_for_scoring(self : rosetta.core.scoring.electron_density.FastDensEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   scoring Methods inherited from rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy: method_type(...) from builtins.PyCapsule method_type(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType Methods inherited from 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. defines_score_for_residue_pair(...) from builtins.PyCapsule defines_score_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, res_moving_wrt_eachother : bool) -> bool   During minimization, energy methods are allowed to decide that they say nothing  about a particular residue pair (e.g. no non-zero energy) and as a result they will not be queried for  a derivative or an energy.  The default implementation returns "true" for all residue pairs.  Context-dependent two-body energies have the option of behaving as if they are context-independent  by returning "false" for residue pairs that do no move wrt each other. eval_intrares_derivatives(...) from builtins.PyCapsule eval_intrares_derivatives(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType   Evaluate the derivative for the intra-residue component of this energy method  for all the atoms in a residue in the context of a particular pose,  and increment the F1 and F2 vectors held in the atom_derivs vector1.  This base class provides a default noop implementation  of this function. The calling function must guarantee that this EnergyMethod has had the  opportunity to update the input ResSingleMinimizationData object for the given residue  in a call to prepare_for_minimization before this function is invoked.  The calling function must also guarantee that there are at least as many entries  in the atom_derivs vector1 as there are atoms in the input rsd. eval_intrares_energy_ext(...) from builtins.PyCapsule eval_intrares_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the intra-residue energy for a given residue using the data held within the  ResSingleMinimizationData object.  This function should be invoked only on derived instances  of this class if they return "true" in a call to their use_extended_intrares_energy_interface  method.  This base class provides a noop implementation for classes that do not implement this  interface, or that do not define intrares energies. eval_intraresidue_dof_derivative(...) from builtins.PyCapsule eval_intraresidue_dof_derivative(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float   Evaluate the DOF derivative for a particular residue.  The Pose merely serves as context,  and the input residue is not required to be a member of the Pose. evaluate_rotamer_background_energies(...) from builtins.PyCapsule evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer/background energies.  Need not be overriden  in derived class -- by default, iterates over all rotamers in the set, and calls  derived class's residue_pair_energy method for each one against the background rotamr evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType   Batch computation of rotamer intrares energies.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType   Batch computation of rotamer intrares energy map.  Need not be overriden in  derived class -- by default, iterates over all rotamers,  and calls derived class's intrares _energy method. evaluate_rotamer_pair_energies(...) from builtins.PyCapsule evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType   Batch computation of rotamer pair energies.  Need not be overriden in  derived class -- by default, iterates over all pairs of rotamers,  and calls the derived class's residue_pair_energy method. requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before derivative evaluation begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested  in doing so. requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.methods.TwoBodyEnergy, pose : rosetta.core.pose.Pose) -> bool   Does this EnergyMethod require the opportunity to examine each residue pair before scoring begins?  Not  all energy methods would.  The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested  in doing so. residue_pair_energy_ext(...) from builtins.PyCapsule residue_pair_energy_ext(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the two-body energies for a particular residue, in the context of a  given Pose, and with the help of a piece of cached data for minimization, increment those  two body energies into the input EnergyMap.  The calling function must guarantee that this  EnergyMethod has had the opportunity to update the input ResPairMinimizationData object  for the given residues in a call to setup_for_minimizing_for_residue_pair before this function is  invoked. This function should not be called unless the use_extended_residue_pair_energy_interface()  method returns "true".  Default implementation provided by this base class calls  utility::exit(). setup_for_derivatives_for_residue(...) from builtins.PyCapsule setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work necessary before evaluating the derivatives for this residue pair setup_for_minimizing_for_residue(...) from builtins.PyCapsule setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Called at the beginning of minimization, allowing this energy method to cache data  pertinent for a single residue in the the ResPairMinimizationData that is used for a  particular residue in the context of a particular Pose.  This base class provides a noop  implementation for this function if there is nothing that the derived class needs to perform  in this setup phase. setup_for_scoring_for_residue(...) from builtins.PyCapsule setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType   Do any setup work should the coordinates of this residue (who is still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called) have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed.  This function is used for both intra-residue setup and pre-inter-residue setup setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType   Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be  of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically  as to possibly require some amount of setup work before scoring should proceed sidechain_sidechain_energy(...) from builtins.PyCapsule sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType   Evaluate the interaction between the sidechain of rsd1 and the  sidechain of rsd2 and accumulate the unweighted energies.  The sum  bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must  equal the unweighted result of a call to residue_pair_energy.  By default, bb_bb & bb_sc return 0 and sc_sc returns  residue pair energy. use_extended_intrares_energy_interface(...) from builtins.PyCapsule use_extended_intrares_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Derived classes wishing to invoke the alternate, extended interface for eval_intrares_energy  during minimization routines should return "true" when this function is invoked on them.  This  class provides a default "return false" implementation so that classes not desiring to take advantage  of this alternate interface need to do nothing. use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule use_extended_residue_pair_energy_interface(rosetta.core.scoring.methods.TwoBodyEnergy) -> bool   Rely on the extended version of the residue_pair_energy function during score-function  evaluation in minimization? The extended version (below) takes a ResPairMinimizationData in which  the derived base class has (or should have) cached a piece of data that will make residue-pair  energy evaluation faster than its absense (e.g. a neighbor list). Derived energy methods should  return 'true' from this function to use the extended interface. The default method implemented  in this class returns 'false' Methods inherited from rosetta.core.scoring.methods.EnergyMethod: defines_high_order_terms(...) from builtins.PyCapsule defines_high_order_terms(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose) -> bool   Should this EnergyMethod have score and derivative evaluation  evaluated both in the context of the whole Pose and in the context  of residue or residue-pairs?  This covers scoring terms like env-smooth  wherein the CBeta's get derivatives for increasing the neighbor counts  for surrounding residues, and terms like constraints, which are definable  on arbitrary number of residues (e.g. more than 2); both of these terms  could be used in RTMin, and both should use the residue and residue-pair  evaluation scheme with the MinimizationGraph for the majority of the  work they do.  (Now, high-order constraints (3-body or above) will not  be properly evaluated within RTMin.).  The default implementation  returns "false". eval_atom_derivative(...) from builtins.PyCapsule eval_atom_derivative(self : rosetta.core.scoring.methods.EnergyMethod, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType   Evaluate the XYZ derivative for an atom in the pose.  Called during the atomtree derivative calculation, atom_tree_minimize.cc,  through the ScoreFunction::eval_atom_derivative intermediary.  F1 and F2 should not zeroed, rather, this class should accumulate its contribution  from this atom's XYZ derivative      The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984)  "Rapid Calculation of First and Second Derivatives of Conformational Energy with  Respect to Dihedral Angles for Proteins. General Recurrent Equations"  Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga,  respectively, of equations 7a & 7b in that paper. finalize_after_derivatives(...) from builtins.PyCapsule finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType   called at the end of derivatives evaluation prepare_rotamers_for_packing(...) from builtins.PyCapsule prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.conformation.RotamerSetBase) -> NoneType   If an energy method needs to cache data in a packing::RotamerSet object before  rotamer energies are calculated, it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. score_types(...) from builtins.PyCapsule score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType   Returns the score types that this energy method computes. setup_for_minimizing(...) from builtins.PyCapsule setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType   Called at the beginning of atom tree minimization, this method  allows the derived class the opportunity to initialize pertinent data  that will be used during minimization.  During minimzation, the chemical  structure of the pose is constant, so assumptions on the number of atoms  per residue and their identities are safe so long as the pose's Energies  object's "use_nblist()" method returns true. setup_for_packing(...) from builtins.PyCapsule setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType   if an energy method needs to cache data in the Energies object,  before packing begins, then it does so during this function. The packer  must ensure this function is called. The default behavior is to do nothing. update_residue_for_packing(...) from builtins.PyCapsule update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType   If the pose changes in the middle of a packing (as happens in rotamer trials) and if  an energy method needs to cache data in the pose that corresponds to its current state,  then the method must update that data when this function is called.  The packer must  ensure this function gets called.  The default behavior is to do nothing. version(...) from builtins.PyCapsule version(rosetta.core.scoring.methods.EnergyMethod) -> int   Return the version of the energy method   class FastDensEnergyCreator(rosetta.core.scoring.methods.EnergyMethodCreator)       Method resolution order: FastDensEnergyCreator 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.electron_density.FastDensEnergyCreator,  : rosetta.core.scoring.electron_density.FastDensEnergyCreator) -> rosetta.core.scoring.electron_density.FastDensEnergyCreator create_energy_method(...) from builtins.PyCapsule create_energy_method(self : rosetta.core.scoring.electron_density.FastDensEnergyCreator,  : rosetta.core.scoring.methods.EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod   Instantiate a new FastDensEnergy score_types_for_method(...) from builtins.PyCapsule score_types_for_method(rosetta.core.scoring.electron_density.FastDensEnergyCreator) -> 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 KromerMann(builtins.object)     /////////     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.electron_density.KromerMann) -> NoneType   2. __init__(self : rosetta.core.scoring.electron_density.KromerMann, c : float, a1 : float, a2 : float, a3 : float, a4 : float, b1 : float, b2 : float, b3 : float, b4 : float) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. f0(...) from builtins.PyCapsule f0(self : rosetta.core.scoring.electron_density.KromerMann, S2 : float) -> float   class OneGaussianScattering(builtins.object)     /////////     Methods defined here: B(...) from builtins.PyCapsule B(self : rosetta.core.scoring.electron_density.OneGaussianScattering, k : float) -> float C(...) from builtins.PyCapsule C(self : rosetta.core.scoring.electron_density.OneGaussianScattering, k : float) -> float __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.electron_density.OneGaussianScattering) -> NoneType   2. __init__(self : rosetta.core.scoring.electron_density.OneGaussianScattering, w : float, s : float) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. a(...) from builtins.PyCapsule a(rosetta.core.scoring.electron_density.OneGaussianScattering) -> int dk(...) from builtins.PyCapsule dk(*args, **kwargs) Overloaded function.   1. dk(self : rosetta.core.scoring.electron_density.OneGaussianScattering, B : float) -> float   2. dk(self : rosetta.core.scoring.electron_density.OneGaussianScattering, B : float, lim : float) -> float k(...) from builtins.PyCapsule k(*args, **kwargs) Overloaded function.   1. k(self : rosetta.core.scoring.electron_density.OneGaussianScattering, B : float) -> float   2. k(self : rosetta.core.scoring.electron_density.OneGaussianScattering, B : float, lim : float) -> float   class poseCoord(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.scoring.electron_density.poseCoord) -> NoneType   2. __init__(self : rosetta.core.scoring.electron_density.poseCoord,  : rosetta.core.scoring.electron_density.poseCoord) -> 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.electron_density.poseCoord,  : rosetta.core.scoring.electron_density.poseCoord) -> rosetta.core.scoring.electron_density.poseCoord Data descriptors defined here: B_ elt_ x_

Functions
		add_dens_scores_from_cmdline_to_scorefxn(...) method of builtins.PyCapsule instance add_dens_scores_from_cmdline_to_scorefxn(scorefxn_ : rosetta.core.scoring.ScoreFunction) -> NoneType   update scorefxn with density scores from commandline conj_map_times(...) method of builtins.PyCapsule instance conj_map_times(map_product : ObjexxFCL::FArray3D<std::complex<double> >, mapA : ObjexxFCL::FArray3D<std::complex<double> >, mapB : ObjexxFCL::FArray3D<std::complex<double> >) -> NoneType convolute_maps(...) method of builtins.PyCapsule instance convolute_maps(mapA : ObjexxFCL::FArray3D<double>, mapB : ObjexxFCL::FArray3D<double>) -> ObjexxFCL::FArray3D<double> factorsLTE19(...) method of builtins.PyCapsule instance factorsLTE19(X : int) -> bool factorsLTE5(...) method of builtins.PyCapsule instance factorsLTE5(X : int) -> bool findSampling(...) method of builtins.PyCapsule instance findSampling(MINSMP : float, NMUL : int) -> int findSampling5(...) method of builtins.PyCapsule instance findSampling5(MINSMP : float, NMUL : int) -> int getDensityMap(...) method of builtins.PyCapsule instance getDensityMap(*args, **kwargs) Overloaded function.   1. getDensityMap() -> rosetta.core.scoring.electron_density.ElectronDensity   The EDM instance   2. getDensityMap(filename : str) -> rosetta.core.scoring.electron_density.ElectronDensity   The EDM instance   3. getDensityMap(filename : str, force_reload : bool) -> rosetta.core.scoring.electron_density.ElectronDensity   The EDM instance getDensityMap_legacy(...) method of builtins.PyCapsule instance getDensityMap_legacy(*args, **kwargs) Overloaded function.   1. getDensityMap_legacy() -> rosetta.core.scoring.electron_density.ElectronDensity   The EDM instance   2. getDensityMap_legacy(filename : str) -> rosetta.core.scoring.electron_density.ElectronDensity   The EDM instance   3. getDensityMap_legacy(filename : str, force_reload : bool) -> rosetta.core.scoring.electron_density.ElectronDensity   The EDM instance get_A(...) method of builtins.PyCapsule instance get_A(elt : str) -> rosetta.core.scoring.electron_density.OneGaussianScattering get_km(...) method of builtins.PyCapsule instance get_km(elt : str) -> rosetta.core.scoring.electron_density.KromerMann interp_dspline(...) method of builtins.PyCapsule instance interp_dspline(*args, **kwargs) Overloaded function.   1. interp_dspline(coeffs : ObjexxFCL::FArray3D<double>, idxX : rosetta.numeric.xyzVector_double_t) -> rosetta.numeric.xyzVector_double_t   2. interp_dspline(coeffs : ObjexxFCL::FArray4D<double>, idxX : rosetta.numeric.xyzVector_double_t, slab : float, gradX : rosetta.numeric.xyzVector_double_t, gradSlab : float) -> NoneType interp_spline(...) method of builtins.PyCapsule instance interp_spline(*args, **kwargs) Overloaded function.   1. interp_spline(coeffs : ObjexxFCL::FArray3D<double>, idxX : rosetta.numeric.xyzVector_double_t) -> float   spline interpolation with periodic boundaries   2. interp_spline(coeffs : ObjexxFCL::FArray4D<double>, slab : float, idxX : rosetta.numeric.xyzVector_double_t) -> float   4d interpolants pos_mod(...) method of builtins.PyCapsule instance pos_mod(*args, **kwargs) Overloaded function.   1. pos_mod(x : float, y : float) -> float   2. pos_mod(x : int, y : int) -> int   3. pos_mod(x : float, y : float) -> float pose_has_nonzero_Bs(...) method of builtins.PyCapsule instance pose_has_nonzero_Bs(pose : rosetta.core.pose.Pose) -> bool   helper function quickly guesses if a pose has non-zero B factors spline_coeffs(...) method of builtins.PyCapsule instance spline_coeffs(*args, **kwargs) Overloaded function.   1. spline_coeffs(data : ObjexxFCL::FArray3D<double>, coeffs : ObjexxFCL::FArray3D<double>) -> NoneType   precompute spline coefficients (float array => double coeffs)   2. spline_coeffs(data : ObjexxFCL::FArray3D<float>, coeffs : ObjexxFCL::FArray3D<double>) -> NoneType   precompute spline coefficients (double array => double coeffs)   3. spline_coeffs(data : ObjexxFCL::FArray4D<double>, coeffs : ObjexxFCL::FArray4D<double>) -> NoneType