rosetta.core.pack.dunbrack.cenrot
index
(built-in)

Bindings for core::pack::dunbrack::cenrot namespace

 
Classes
       
builtins.object
CentroidRotamerSampleData
rosetta.core.pack.rotamers.SingleResidueRotamerLibrary(builtins.object)
SingleResidueCenrotLibrary
rosetta.core.pack.rotamers.SingleResidueRotamerLibraryCreator(builtins.object)
SingleResidueCenrotLibraryCreator
rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy(rosetta.core.scoring.methods.OneBodyEnergy)
CenRotDunEnergy
rosetta.core.scoring.methods.EnergyMethodCreator(builtins.object)
CenRotDunEnergyCreator
rosetta.utility.SingletonBase_core_pack_dunbrack_cenrot_CenrotLibrary_t(builtins.object)
CenrotLibrary

 
class CenRotDunEnergy(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy)
    
Method resolution order:
CenRotDunEnergy
rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy
rosetta.core.scoring.methods.OneBodyEnergy
rosetta.core.scoring.methods.EnergyMethod
builtins.object

Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(handle) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy,  : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy) -> rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy
clone(...) from builtins.PyCapsule
clone(rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy) -> rosetta.core.scoring.methods.EnergyMethod
 
clone
defines_dof_derivatives(...) from builtins.PyCapsule
defines_dof_derivatives(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy, p : rosetta.core.pose.Pose) -> bool
 
Yes.  The DunbrackEnergy defines derivatives
 for phi/psi and the chi dihedrals.
eval_dof_derivative(...) from builtins.PyCapsule
eval_dof_derivative(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy, dof_id : rosetta.core.id.DOF_ID, tor_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float
 
Deprecated.
eval_residue_derivatives(...) from builtins.PyCapsule
eval_residue_derivatives(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType
eval_residue_dof_derivative(...) from builtins.PyCapsule
eval_residue_dof_derivative(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float
 
Evaluate the phi/psi and chi dihedral derivatives
 for the input residue.
finalize_total_energy(...) from builtins.PyCapsule
finalize_total_energy(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.scoring.EMapVector) -> NoneType
indicate_required_context_graphs(...) from builtins.PyCapsule
indicate_required_context_graphs(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy,  : rosetta.utility.vector1_bool) -> NoneType
minimize_in_whole_structure_context(...) from builtins.PyCapsule
minimize_in_whole_structure_context(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy,  : rosetta.core.pose.Pose) -> bool
residue_energy(...) from builtins.PyCapsule
residue_energy(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
setup_for_scoring(...) from builtins.PyCapsule
setup_for_scoring(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergy, pose : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction) -> NoneType
 
//////////////////////////////////////////////////////////////////////////

Methods inherited from rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy:
method_type(...) from builtins.PyCapsule
method_type(rosetta.core.scoring.methods.ContextIndependentOneBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType
 
Returns the ci_1b element of the EnergyMethodType enumeration; this
 method should NOT be overridden by derived classes.

Methods inherited from rosetta.core.scoring.methods.OneBodyEnergy:
defines_score_for_residue(...) from builtins.PyCapsule
defines_score_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy,  : rosetta.core.conformation.Residue) -> bool
 
During minimization, energy methods are allowed to decide that they say nothing
 about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for
 a derivative or an energy.  The default behavior is to return "true" for all residues.
requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule
requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool
 
Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins?  Not
 all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested
 in doing so.
requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule
requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.methods.OneBodyEnergy, pose : rosetta.core.pose.Pose) -> bool
 
Does this EnergyMethod require the opportunity to examine the residue before scoring begins?  Not
 all energy methods would.  The ScoreFunction will not ask energy methods to examine residues that are uninterested
 in doing so.
residue_energy_ext(...) from builtins.PyCapsule
residue_energy_ext(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, min_data : core::scoring::ResSingleMinimizationData, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
 
Evaluate the one-body energies for a particular residue, in the context of a
 given Pose, and with the help of a piece of cached data for minimization, increment those
 one body energies into the input EnergyMap.  The calling function must guarantee that this
 EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object
 for the given residue in a call to setup_for_minimizing_for_residue before this function is
 invoked. This function should not be called unless the use_extended_residue_energy_interface()
 method returns "true".  Default implementation provided by this base class calls
 utility::exit(). The Pose merely serves as context, and the input residue is not required
 to be a member of the Pose.
setup_for_derivatives_for_residue(...) from builtins.PyCapsule
setup_for_derivatives_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType
 
Do any setup work necessary before evaluating the derivatives for this residue
setup_for_minimizing_for_residue(...) from builtins.PyCapsule
setup_for_minimizing_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase,  : core::scoring::ResSingleMinimizationData) -> NoneType
 
Called at the beginning of minimization, allowing this energy method to cache data
 pertinent for a single residue in the the ResSingleMinimizationData that is used for a
 particular residue in the context of a particular Pose.  This base class provides a noop
 implementation for this function if there is nothing that the derived class needs to perform
 in this setup phase.   The Pose merely serves as context, and the input residue is not
 required to be a member of the Pose.
setup_for_scoring_for_residue(...) from builtins.PyCapsule
setup_for_scoring_for_residue(self : rosetta.core.scoring.methods.OneBodyEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : core::scoring::ResSingleMinimizationData) -> NoneType
 
Do any setup work should the coordinates of this residue, who is still guaranteed to be
 of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically
 as to possibly require some amount of setup work before scoring should proceed
use_extended_residue_energy_interface(...) from builtins.PyCapsule
use_extended_residue_energy_interface(rosetta.core.scoring.methods.OneBodyEnergy) -> bool
 
Rely on the extended version of the residue_energy function during score-function
 evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData.
 Return 'true' for the extended version.  The default method implemented in this class returns 'false'

Methods inherited from 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_derivatives(...) from builtins.PyCapsule
setup_for_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType
 
Called immediately before atom- and DOF-derivatives are calculated
 allowing the derived class a chance to prepare for future calls.
setup_for_minimizing(...) from builtins.PyCapsule
setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.core.scoring.ScoreFunction,  : rosetta.core.kinematics.MinimizerMapBase) -> NoneType
 
Called at the beginning of atom tree minimization, this method
 allows the derived class the opportunity to initialize pertinent data
 that will be used during minimization.  During minimzation, the chemical
 structure of the pose is constant, so assumptions on the number of atoms
 per residue and their identities are safe so long as the pose's Energies
 object's "use_nblist()" method returns true.
setup_for_packing(...) from builtins.PyCapsule
setup_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose,  : rosetta.utility.vector1_bool,  : rosetta.utility.vector1_bool) -> NoneType
 
if an energy method needs to cache data in the Energies object,
 before packing begins, then it does so during this function. The packer
 must ensure this function is called. The default behavior is to do nothing.
update_residue_for_packing(...) from builtins.PyCapsule
update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod,  : rosetta.core.pose.Pose, resid : int) -> NoneType
 
If the pose changes in the middle of a packing (as happens in rotamer trials) and if
 an energy method needs to cache data in the pose that corresponds to its current state,
 then the method must update that data when this function is called.  The packer must
 ensure this function gets called.  The default behavior is to do nothing.
version(...) from builtins.PyCapsule
version(rosetta.core.scoring.methods.EnergyMethod) -> int
 
Return the version of the energy method

 
class CenRotDunEnergyCreator(rosetta.core.scoring.methods.EnergyMethodCreator)
    
Method resolution order:
CenRotDunEnergyCreator
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.pack.dunbrack.cenrot.CenRotDunEnergyCreator,  : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergyCreator) -> rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergyCreator
create_energy_method(...) from builtins.PyCapsule
create_energy_method(self : rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergyCreator,  : core::scoring::methods::EnergyMethodOptions) -> rosetta.core.scoring.methods.EnergyMethod
 
Instantiate a new CenRotDunEnergy
score_types_for_method(...) from builtins.PyCapsule
score_types_for_method(rosetta.core.pack.dunbrack.cenrot.CenRotDunEnergyCreator) -> 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 CenrotLibrary(rosetta.utility.SingletonBase_core_pack_dunbrack_cenrot_CenrotLibrary_t)
    ////////////////////////////////////////////////////////////////////////////
 
 
Stores and handles loading of centroid rotamers for the canonical amino acids.
 
 
Method resolution order:
CenrotLibrary
rosetta.utility.SingletonBase_core_pack_dunbrack_cenrot_CenrotLibrary_t
builtins.object

Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
get_cenrot_library_by_aa(...) from builtins.PyCapsule
get_cenrot_library_by_aa(self : rosetta.core.pack.dunbrack.cenrot.CenrotLibrary, aa : rosetta.core.chemical.AA) -> core::pack::dunbrack::cenrot::SingleResidueCenrotLibrary

Methods inherited from rosetta.utility.SingletonBase_core_pack_dunbrack_cenrot_CenrotLibrary_t:
get_instance(...) from builtins.PyCapsule
get_instance() -> core::pack::dunbrack::cenrot::CenrotLibrary

 
class CentroidRotamerSampleData(builtins.object)
    Simple class storing all the data for one centroid-rotamer well
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> NoneType
 
2. __init__(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, p : float, d : float, a : float, w : float, vd : float, va : float, vw : float) -> NoneType
 
3. __init__(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, cs : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
angle(...) from builtins.PyCapsule
angle(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> float
assign_best_rotamer(...) from builtins.PyCapsule
assign_best_rotamer(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, sample : rosetta.utility.fixedsizearray1_double_3_t) -> NoneType
 
generate the best rot (mean of the well)
assign_random_rotamer(...) from builtins.PyCapsule
assign_random_rotamer(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, sample : rosetta.utility.fixedsizearray1_double_3_t, RG : rosetta.numeric.random.RandomGenerator) -> NoneType
 
generate a random rot inside the well
cal_delta_internal_coordinates(...) from builtins.PyCapsule
cal_delta_internal_coordinates(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, rsd : rosetta.core.conformation.Residue, delta_d : float, delta_a : float, delta_w : float) -> float
cal_delta_internal_coordinates_squared(...) from builtins.PyCapsule
cal_delta_internal_coordinates_squared(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, rsd : rosetta.core.conformation.Residue, d_sq : float, a_sq : float, w_sq : float) -> float
 
return the value of angle (in rad)
cal_distance(...) from builtins.PyCapsule
cal_distance(*args, **kwargs)
Overloaded function.
 
1. cal_distance(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, sample : rosetta.utility.fixedsizearray1_double_3_t) -> float
 
DOF3 sample: (dis, ange, dih)
 calculate the distance between this rot and given CEN
 
2. cal_distance(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, sample : rosetta.utility.fixedsizearray1_double_3_t, use_xyz : bool) -> float
 
DOF3 sample: (dis, ange, dih)
 calculate the distance between this rot and given CEN
cal_distance_squared(...) from builtins.PyCapsule
cal_distance_squared(*args, **kwargs)
Overloaded function.
 
1. cal_distance_squared(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, sample : rosetta.utility.fixedsizearray1_double_3_t) -> float
 
2. cal_distance_squared(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, sample : rosetta.utility.fixedsizearray1_double_3_t, use_xyz : bool) -> float
 
3. cal_distance_squared(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, rsd : rosetta.core.conformation.Residue) -> float
dihedral(...) from builtins.PyCapsule
dihedral(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> float
distance(...) from builtins.PyCapsule
distance(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> float
energy(...) from builtins.PyCapsule
energy(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> float
norm_factor(...) from builtins.PyCapsule
norm_factor(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> float
private_data_to_public_array(...) from builtins.PyCapsule
private_data_to_public_array(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> NoneType
prob(...) from builtins.PyCapsule
prob(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> float
public_array_to_private_data(...) from builtins.PyCapsule
public_array_to_private_data(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> NoneType
sd_ang(...) from builtins.PyCapsule
sd_ang(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> float
sd_dih(...) from builtins.PyCapsule
sd_dih(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> float
sd_dis(...) from builtins.PyCapsule
sd_dis(rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData) -> float
set_angle(...) from builtins.PyCapsule
set_angle(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, a : float) -> NoneType
set_dihedral(...) from builtins.PyCapsule
set_dihedral(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, w : float) -> NoneType
set_distance(...) from builtins.PyCapsule
set_distance(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, d : float) -> NoneType
set_prob(...) from builtins.PyCapsule
set_prob(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, p : float) -> NoneType
set_sd_ang(...) from builtins.PyCapsule
set_sd_ang(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, s : float) -> NoneType
set_sd_dih(...) from builtins.PyCapsule
set_sd_dih(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, s : float) -> NoneType
set_sd_dis(...) from builtins.PyCapsule
set_sd_dis(self : rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData, s : float) -> NoneType

 
class SingleResidueCenrotLibrary(rosetta.core.pack.rotamers.SingleResidueRotamerLibrary)
    ///////////////////////////////////////////////////////////////////////////
 
 
Method resolution order:
SingleResidueCenrotLibrary
rosetta.core.pack.rotamers.SingleResidueRotamerLibrary
builtins.object

Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self : handle, aa : rosetta.core.chemical.AA) -> NoneType
 
2. __init__(handle, rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
aa(...) from builtins.PyCapsule
aa(rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary) -> rosetta.core.chemical.AA
assign(...) from builtins.PyCapsule
assign(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary,  : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary) -> rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary
assign_random_rotamer_with_bias(...) from builtins.PyCapsule
assign_random_rotamer_with_bias(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, scratch : rosetta.core.pack.dunbrack.RotamerLibraryScratchSpace, RG : rosetta.numeric.random.RandomGenerator, new_chi_angles : rosetta.utility.vector1_double, perturb_from_rotamer_center : bool) -> NoneType
best_rotamer_energy(...) from builtins.PyCapsule
best_rotamer_energy(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, rsd : rosetta.core.conformation.Residue, curr_rotamer_only : bool, scratch : rosetta.core.pack.dunbrack.RotamerLibraryScratchSpace) -> float
 
Returns the energy of the lowest-energy rotamer accessible to the given residue
 (based on e.g. its current phi and psi values).
 If curr_rotamer_only is true, then consider only the idealized version of the
 residue's current rotamer (local optimum); otherwise, consider all rotamers (global optimum).
eval_rotameric_energy_bb_dof_deriv(...) from builtins.PyCapsule
eval_rotameric_energy_bb_dof_deriv(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, rsd : rosetta.core.conformation.Residue, scratch : rosetta.core.pack.dunbrack.RotamerLibraryScratchSpace) -> float
eval_rotameric_energy_deriv(...) from builtins.PyCapsule
eval_rotameric_energy_deriv(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, rsd : rosetta.core.conformation.Residue, scratch : rosetta.core.pack.dunbrack.RotamerLibraryScratchSpace, eval_deriv : bool) -> float
fill_rotamer_vector(...) from builtins.PyCapsule
fill_rotamer_vector(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, task : rosetta.core.pack.task.PackerTask, packer_neighbor_graph : rosetta.core.graph.Graph, concrete_residue : rosetta.core.chemical.ResidueType, existing_residue : rosetta.core.conformation.Residue, extra_chi_steps : rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t, buried : bool, rotamers : rosetta.utility.vector1_std_shared_ptr_core_conformation_Residue_t) -> NoneType
get_closest_rotamer(...) from builtins.PyCapsule
get_closest_rotamer(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, rsd : rosetta.core.conformation.Residue, nrot : int, dis : float) -> rosetta.core.pack.dunbrack.cenrot.CentroidRotamerSampleData
get_rotamer_samples(...) from builtins.PyCapsule
get_rotamer_samples(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, rsd : rosetta.core.conformation.Residue) -> rosetta.utility.vector1_core_pack_dunbrack_cenrot_CentroidRotamerSampleData
read_from_file(...) from builtins.PyCapsule
read_from_file(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, infile : rosetta.utility.io.izstream, first_line_three_letter_code_already_read : bool) -> str
rotamer_energy(...) from builtins.PyCapsule
rotamer_energy(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, rsd : rosetta.core.conformation.Residue, scratch : rosetta.core.pack.dunbrack.RotamerLibraryScratchSpace) -> float
 
Virtual functions required by the base classes
rotamer_energy_deriv(...) from builtins.PyCapsule
rotamer_energy_deriv(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, rsd : rosetta.core.conformation.Residue, scratch : rosetta.core.pack.dunbrack.RotamerLibraryScratchSpace) -> float
write_to_file(...) from builtins.PyCapsule
write_to_file(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibrary, out : rosetta.utility.io.ozstream) -> NoneType

Methods inherited from rosetta.core.pack.rotamers.SingleResidueRotamerLibrary:
__eq__(...) from builtins.PyCapsule
__eq__(self : rosetta.core.pack.rotamers.SingleResidueRotamerLibrary,  : rosetta.core.pack.rotamers.SingleResidueRotamerLibrary) -> bool
 
Equality test for equivalence.
 Two SingleResidueRotamerLibraries test equal if and only if they represent the exact same behavior
bump_check(...) from builtins.PyCapsule
bump_check(self : rosetta.core.pack.rotamers.SingleResidueRotamerLibrary, rotamer : rosetta.core.conformation.Residue, resid : int, sf : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, task : core::pack::task::PackerTask, packer_neighbor_graph : rosetta.core.graph.Graph) -> float
 
Computes the "bump energy" of a rotamer: the bump energy is the
 sum of rotamer's interactions with 1) the backbone-and-side chains of
 neighboring residues that are held fixed during this repacking optimization
 and 2) the backbones of neighboring residues that are changable during this
 repacking optimization.
bump_filter(...) from builtins.PyCapsule
bump_filter(self : rosetta.core.pack.rotamers.SingleResidueRotamerLibrary, rotamers : rosetta.utility.vector1_std_shared_ptr_core_conformation_Residue_t, resid : int, sf : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, task : core::pack::task::PackerTask, packer_neighbor_graph : rosetta.core.graph.Graph) -> NoneType
 
Filter a RotamerVector by "bump energy" of a rotamer:
 All rotamers with bump energies over a certain threshold will be discarded
 Exception: if all rotamers are over the threshold, one rotamer (with the lowest
 bump energy) will be reserved.
 The vector "rotamers" will be modified "in-place"
compute_proton_chi_samplings(...) from builtins.PyCapsule
compute_proton_chi_samplings(self : rosetta.core.pack.rotamers.SingleResidueRotamerLibrary, concrete_residue : rosetta.core.chemical.ResidueType, rlt : core::pack::task::ResidueLevelTask, buried : bool) -> rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t
 
Return a vector (indexed by proton_chi number) of vectors of dihedral values
 to use in proton chi sampling
current_rotamer(...) from builtins.PyCapsule
current_rotamer(self : rosetta.core.pack.rotamers.SingleResidueRotamerLibrary, rotamers : rosetta.utility.vector1_std_shared_ptr_core_conformation_Residue_t, resid : int, task : core::pack::task::PackerTask, concrete_residue : rosetta.core.chemical.ResidueType, existing_residue : rosetta.core.conformation.Residue) -> int
 
Adds the current rotamer to rotamer vector, if the Rotlib supports it
 
 
 This is in this class mainly because of historical
 behavior of certain rotamer libraries not supporting current rotamers
emergency_rotamer(...) from builtins.PyCapsule
emergency_rotamer(self : rosetta.core.pack.rotamers.SingleResidueRotamerLibrary, rotamers : rosetta.utility.vector1_std_shared_ptr_core_conformation_Residue_t, resid : int, pose : rosetta.core.pose.Pose, task : core::pack::task::PackerTask, concrete_residue : rosetta.core.chemical.ResidueType, existing_residue : rosetta.core.conformation.Residue) -> NoneType
 
Generate an "emergency rotamer" if we don't have any
 
 
 This is in this class mainly because of historical
 behavior of certain rotamer libraries not supporting current rotamers
expand_proton_chis(...) from builtins.PyCapsule
expand_proton_chis(*args, **kwargs)
Overloaded function.
 
1. expand_proton_chis(self : rosetta.core.pack.rotamers.SingleResidueRotamerLibrary, sampling : rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t, concrete_residue : rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_shared_ptr_core_pack_dunbrack_ChiSet_t
 
Given a vector of vectors of dihedrals to sample on proton chis,
 Will create the ChiSet vector combinitorially on those chi values
 (Note: The ChiSets are only valid/defined over the proton chis.)
 
2. expand_proton_chis(self : rosetta.core.pack.rotamers.SingleResidueRotamerLibrary, sampling : rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t, concrete_residue : rosetta.core.chemical.ResidueType, max_rotamers : int) -> rosetta.utility.vector1_std_shared_ptr_core_pack_dunbrack_ChiSet_t
 
Given a vector of vectors of dihedrals to sample on proton chis,
 Will create the ChiSet vector combinitorially on those chi values
 (Note: The ChiSets are only valid/defined over the proton chis.)
virtual_sidechain(...) from builtins.PyCapsule
virtual_sidechain(self : rosetta.core.pack.rotamers.SingleResidueRotamerLibrary, rotamers : rosetta.utility.vector1_std_shared_ptr_core_conformation_Residue_t, resid : int, pose : rosetta.core.pose.Pose, task : core::pack::task::PackerTask, concrete_residue : rosetta.core.chemical.ResidueType, existing_residue : rosetta.core.conformation.Residue) -> rosetta.utility.vector1_std_shared_ptr_core_conformation_Residue_t
 
Add a virtualized sidechain to the rotamer vector if
 settings call for it.

 
class SingleResidueCenrotLibraryCreator(rosetta.core.pack.rotamers.SingleResidueRotamerLibraryCreator)
    
Method resolution order:
SingleResidueCenrotLibraryCreator
rosetta.core.pack.rotamers.SingleResidueRotamerLibraryCreator
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.pack.dunbrack.cenrot.SingleResidueCenrotLibraryCreator,  : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibraryCreator) -> rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibraryCreator
create(...) from builtins.PyCapsule
create(self : rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibraryCreator,  : rosetta.core.chemical.ResidueType) -> rosetta.core.pack.rotamers.SingleResidueRotamerLibrary
keyname(...) from builtins.PyCapsule
keyname(rosetta.core.pack.dunbrack.cenrot.SingleResidueCenrotLibraryCreator) -> str