rosetta.protocols.jumping		index
(built-in)

Bindings for protocols::jumping namespace

 
Classes
       
builtins.object
BaseDisulfPairingLibrary
DisulfPairingLibrary
StandardDisulfPairingLibrary
BaseJumpSetup
JumpSelector
JumpSetup
JumpsFromAllPairings
ResiduePairJumpSetup
SheetBuilder
RandomSheetBuilder
BasePairingLibrary
PairingLibrary
SpecificGeometryLibrary
StandardPairingLibrary
DisulfPairing
DisulfTemplate
Interval
JumpSample
MembraneJump
PairingTemplate
ResiduePairJump
ResiduePairJumpSingle
SameStrand
cstType
dofType
rosetta.core.scoring.func.Func(builtins.object)
ChainbreakDistFunc

 
class BaseDisulfPairingLibrary(builtins.object)
     Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self : rosetta.protocols.jumping.BaseDisulfPairingLibrary,  : rosetta.protocols.jumping.BaseDisulfPairingLibrary) -> NoneType
 
2. __init__(rosetta.protocols.jumping.BaseDisulfPairingLibrary) -> 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.protocols.jumping.BaseDisulfPairingLibrary,  : rosetta.protocols.jumping.BaseDisulfPairingLibrary) -> rosetta.protocols.jumping.BaseDisulfPairingLibrary

 
class BaseJumpSetup(builtins.object)
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
virtual base class: can create a set of jumps and cuts
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.protocols.jumping.BaseJumpSetup, rosetta.protocols.jumping.BaseJumpSetup) -> NoneType
 
2. __init__(rosetta.protocols.jumping.BaseJumpSetup) -> 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.protocols.jumping.BaseJumpSetup,  : rosetta.protocols.jumping.BaseJumpSetup) -> rosetta.protocols.jumping.BaseJumpSetup
clean_jumps(...) from builtins.PyCapsule
clean_jumps(self : rosetta.protocols.jumping.BaseJumpSetup,  : rosetta.protocols.jumping.JumpSample) -> rosetta.protocols.jumping.JumpSample
 
take from a given JumpSample only those Jumps, which could also have been created by create_jump_sample()
create_jump_sample(...) from builtins.PyCapsule
create_jump_sample(rosetta.protocols.jumping.BaseJumpSetup) -> rosetta.protocols.jumping.JumpSample
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.BaseJumpSetup,  : rosetta.protocols.jumping.JumpSample, mm : rosetta.core.kinematics.MoveMap) -> rosetta.core.fragment.FragSet
 
returns an ordered FragSet that is compatible with the JumpSample
 default: generate jumps from ss-library according to JumpSample
type_name(...) from builtins.PyCapsule
type_name(rosetta.protocols.jumping.BaseJumpSetup) -> str

 
class BasePairingLibrary(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.
assign(...) from builtins.PyCapsule
assign(self : rosetta.protocols.jumping.BasePairingLibrary,  : rosetta.protocols.jumping.BasePairingLibrary) -> rosetta.protocols.jumping.BasePairingLibrary
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.BasePairingLibrary, pairings : rosetta.utility.vector1_core_scoring_dssp_Pairing, mm : rosetta.core.kinematics.MoveMap, bWithTorsion : bool, frags_accumulator : rosetta.core.fragment.FragSet) -> NoneType

 
class ChainbreakDistFunc(rosetta.core.scoring.func.Func)
    
Method resolution order:
ChainbreakDistFunc
rosetta.core.scoring.func.Func
builtins.object
Methods defined here:
__eq__(...) from builtins.PyCapsule
__eq__(self : rosetta.protocols.jumping.ChainbreakDistFunc, other : rosetta.core.scoring.func.Func) -> bool
__init__(...) from builtins.PyCapsule
__init__(self : handle, x0_in : float) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.protocols.jumping.ChainbreakDistFunc,  : rosetta.protocols.jumping.ChainbreakDistFunc) -> rosetta.protocols.jumping.ChainbreakDistFunc
clone(...) from builtins.PyCapsule
clone(rosetta.protocols.jumping.ChainbreakDistFunc) -> rosetta.core.scoring.func.Func
dfunc(...) from builtins.PyCapsule
dfunc(self : rosetta.protocols.jumping.ChainbreakDistFunc, x : float) -> float
func(...) from builtins.PyCapsule
func(self : rosetta.protocols.jumping.ChainbreakDistFunc, x : float) -> float
same_type_as_me(...) from builtins.PyCapsule
same_type_as_me(self : rosetta.protocols.jumping.ChainbreakDistFunc, other : rosetta.core.scoring.func.Func) -> bool
Methods inherited from rosetta.core.scoring.func.Func:
__ne__(...) from builtins.PyCapsule
__ne__(self : rosetta.core.scoring.func.Func, other : rosetta.core.scoring.func.Func) -> bool
 
inequality operator -- simply the negation of the (virtual) equality operator
__str__(...) from builtins.PyCapsule
__str__(rosetta.core.scoring.func.Func) -> str
estimate_dfunc(...) from builtins.PyCapsule
estimate_dfunc(*args, **kwargs)
Overloaded function.
 
1. estimate_dfunc(self : rosetta.core.scoring.func.Func, r : float) -> float
 
Estimates the derivative of this function at a given radius by
 calculating the slope of the secant line from func(r) and func(r+1e-05).
 
2. estimate_dfunc(self : rosetta.core.scoring.func.Func, r : float, h : float) -> float
 
Estimates the derivative of this function at a given radius by
 calculating the slope of the secant line from func(r) and func(r+h).

 
class DisulfPairing(builtins.object)
     Methods defined here:
__eq__(...) from builtins.PyCapsule
__eq__(self : rosetta.protocols.jumping.DisulfPairing, p : rosetta.protocols.jumping.DisulfPairing) -> bool
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.protocols.jumping.DisulfPairing) -> NoneType
 
2. __init__(self : rosetta.protocols.jumping.DisulfPairing, pos1_in : int, pos2_in : int) -> NoneType
 
3. __init__(self : rosetta.protocols.jumping.DisulfPairing,  : ObjexxFCL::FArray1A<int>) -> NoneType
 
4. __init__(self : rosetta.protocols.jumping.DisulfPairing, pos1_in : int, pos2_in : int, ori_in : int, pleat_in : int) -> NoneType
 
5. __init__(self : rosetta.protocols.jumping.DisulfPairing,  : rosetta.protocols.jumping.DisulfPairing) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__str__(...) from builtins.PyCapsule
__str__(rosetta.protocols.jumping.DisulfPairing) -> str
Data descriptors defined here:
pos1
pos2
seq_sep
ss_type

 
class DisulfPairingLibrary(BaseDisulfPairingLibrary)
    
Method resolution order:
DisulfPairingLibrary
BaseDisulfPairingLibrary
builtins.object
Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.protocols.jumping.DisulfPairingLibrary) -> NoneType
 
2. __init__(self : rosetta.protocols.jumping.DisulfPairingLibrary,  : rosetta.protocols.jumping.DisulfPairingLibrary) -> 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.protocols.jumping.DisulfPairingLibrary,  : rosetta.protocols.jumping.DisulfPairingLibrary) -> rosetta.protocols.jumping.DisulfPairingLibrary
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.DisulfPairingLibrary, pairings : rosetta.utility.vector1_protocols_jumping_DisulfPairing, mm : rosetta.core.kinematics.MoveMap, bWithTorsion : bool, frags_accumulator : rosetta.core.fragment.FragSet) -> NoneType
read_from_file(...) from builtins.PyCapsule
read_from_file(self : rosetta.protocols.jumping.DisulfPairingLibrary, fn : str) -> NoneType
size(...) from builtins.PyCapsule
size(rosetta.protocols.jumping.DisulfPairingLibrary) -> int

 
class DisulfTemplate(builtins.object)
     Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self : rosetta.protocols.jumping.DisulfTemplate, c : str, s1 : str, s2 : str, s3 : str) -> NoneType
 
2. __init__(self : rosetta.protocols.jumping.DisulfTemplate, s1 : str, s2 : str, s3 : str) -> NoneType
 
3. __init__(self : rosetta.protocols.jumping.DisulfTemplate,  : rosetta.protocols.jumping.DisulfTemplate) -> 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.protocols.jumping.DisulfTemplate,  : rosetta.protocols.jumping.DisulfTemplate) -> rosetta.protocols.jumping.DisulfTemplate
Data descriptors defined here:
atoms_downstream_
atoms_upstream_
omega
phi
psi
rt_
secstruct

 
class Interval(builtins.object)
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
two numbers, i.e., jump start end residue, or cut-regions...
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.protocols.jumping.Interval) -> NoneType
 
2. __init__(self : rosetta.protocols.jumping.Interval, start : int, end : int) -> NoneType
 
3. __init__(self : rosetta.protocols.jumping.Interval,  : rosetta.protocols.jumping.Interval) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
end(...) from builtins.PyCapsule
end(rosetta.protocols.jumping.Interval) -> int
start(...) from builtins.PyCapsule
start(rosetta.protocols.jumping.Interval) -> int
stop(...) from builtins.PyCapsule
stop(rosetta.protocols.jumping.Interval) -> int
Data descriptors defined here:
end_
start_

 
class JumpSample(builtins.object)
     Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.protocols.jumping.JumpSample) -> NoneType
 
2. __init__(self : rosetta.protocols.jumping.JumpSample,  : protocols::jumping::JumpSetup) -> NoneType
 
3. __init__(rosetta.protocols.jumping.JumpSample, int, int, ObjexxFCL::FArray2D<int>, ObjexxFCL::FArray1D<int>) -> NoneType
 
doc
 
4. __init__(self : rosetta.protocols.jumping.JumpSample, total_residue : int, njump : int, jumps : ObjexxFCL::FArray2D<int>, cuts : ObjexxFCL::FArray1D<int>, root : int) -> NoneType
 
5. __init__(rosetta.protocols.jumping.JumpSample, int, int, ObjexxFCL::FArray2D<int>, ObjexxFCL::FArray2D<std::string>, ObjexxFCL::FArray1D<int>) -> NoneType
 
doc
 
6. __init__(self : rosetta.protocols.jumping.JumpSample, total_residue : int, njump : int, jumps : ObjexxFCL::FArray2D<int>, jump_atoms : ObjexxFCL::FArray2D<std::string>, cuts : ObjexxFCL::FArray1D<int>, root : int) -> NoneType
 
7. __init__(rosetta.protocols.jumping.JumpSample, int, rosetta.utility.vector1_core_scoring_dssp_Pairing, ObjexxFCL::FArray1D<float>) -> NoneType
 
doc
 
8. __init__(self : rosetta.protocols.jumping.JumpSample, total_residue : int, jumps : rosetta.utility.vector1_core_scoring_dssp_Pairing, cut_probability : ObjexxFCL::FArray1D<float>, root : int) -> NoneType
 
9. __init__(rosetta.protocols.jumping.JumpSample, int, rosetta.utility.vector1_core_scoring_dssp_Pairing, rosetta.core.fragment.SecondaryStructure) -> NoneType
 
doc
 
10. __init__(self : rosetta.protocols.jumping.JumpSample, total_residue : int, jumps : rosetta.utility.vector1_core_scoring_dssp_Pairing, ss_def : rosetta.core.fragment.SecondaryStructure, root : int) -> NoneType
 
11. __init__(self : rosetta.protocols.jumping.JumpSample, f : rosetta.core.kinematics.FoldTree) -> NoneType
 
12. __init__(self : rosetta.protocols.jumping.JumpSample, f : rosetta.core.kinematics.FoldTree) -> NoneType
 
13. __init__(self : rosetta.protocols.jumping.JumpSample,  : rosetta.protocols.jumping.JumpSample) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__str__(...) from builtins.PyCapsule
__str__(rosetta.protocols.jumping.JumpSample) -> str
add_chainbreaks(...) from builtins.PyCapsule
add_chainbreaks(*args, **kwargs)
Overloaded function.
 
1. add_chainbreaks(self : rosetta.protocols.jumping.JumpSample, pose : rosetta.core.pose.Pose) -> NoneType
 
2. add_chainbreaks(self : rosetta.protocols.jumping.JumpSample, pose : rosetta.core.pose.Pose, max_dist : int,  : rosetta.core.kinematics.ShortestPathInFoldTree) -> NoneType
add_chainbreaks_as_distance_constraint(...) from builtins.PyCapsule
add_chainbreaks_as_distance_constraint(*args, **kwargs)
Overloaded function.
 
1. add_chainbreaks_as_distance_constraint(self : rosetta.protocols.jumping.JumpSample, pose : rosetta.core.pose.Pose) -> NoneType
 
2. add_chainbreaks_as_distance_constraint(self : rosetta.protocols.jumping.JumpSample, pose : rosetta.core.pose.Pose, max_dist : int, sp : rosetta.core.kinematics.ShortestPathInFoldTree) -> NoneType
assign(...) from builtins.PyCapsule
assign(self : rosetta.protocols.jumping.JumpSample,  : rosetta.protocols.jumping.JumpSample) -> rosetta.protocols.jumping.JumpSample
cuts(...) from builtins.PyCapsule
cuts(rosetta.protocols.jumping.JumpSample) -> ObjexxFCL::FArray1D<int>
downstream_res_nr(...) from builtins.PyCapsule
downstream_res_nr(self : rosetta.protocols.jumping.JumpSample, jump_nr : int) -> int
dump_pymol(...) from builtins.PyCapsule
dump_pymol(self : rosetta.protocols.jumping.JumpSample, fn : str) -> NoneType
 
dump file with little pymol script that shows jumps and cuts
fold_tree(...) from builtins.PyCapsule
fold_tree(rosetta.protocols.jumping.JumpSample) -> rosetta.core.kinematics.FoldTree
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.JumpSample, pairings : rosetta.protocols.jumping.PairingLibrary,  : rosetta.core.kinematics.MoveMap, bWithTorsion : bool,  : rosetta.core.fragment.FrameList) -> NoneType
generate_jump_frames(...) from builtins.PyCapsule
generate_jump_frames(*args, **kwargs)
Overloaded function.
 
1. generate_jump_frames(self : rosetta.protocols.jumping.JumpSample,  : rosetta.core.fragment.FrameList,  : rosetta.core.kinematics.MoveMap) -> NoneType
 
2. generate_jump_frames(self : rosetta.protocols.jumping.JumpSample,  : rosetta.core.fragment.FrameList,  : rosetta.core.kinematics.MoveMap, bWithTorsion : bool) -> NoneType
get_pairing(...) from builtins.PyCapsule
get_pairing(self : rosetta.protocols.jumping.JumpSample, res1 : int, res2 : int) -> rosetta.core.scoring.dssp.Pairing
has_orientation_and_pleating(...) from builtins.PyCapsule
has_orientation_and_pleating(rosetta.protocols.jumping.JumpSample) -> bool
is_valid(...) from builtins.PyCapsule
is_valid(rosetta.protocols.jumping.JumpSample) -> bool
jump_atoms(...) from builtins.PyCapsule
jump_atoms(rosetta.protocols.jumping.JumpSample) -> ObjexxFCL::FArray2D<std::string>
jumps(...) from builtins.PyCapsule
jumps(rosetta.protocols.jumping.JumpSample) -> ObjexxFCL::FArray2D<int>
remove_chainbreaks(...) from builtins.PyCapsule
remove_chainbreaks(self : rosetta.protocols.jumping.JumpSample, pose : rosetta.core.pose.Pose) -> NoneType
resize(...) from builtins.PyCapsule
resize(self : rosetta.protocols.jumping.JumpSample, njump : int) -> NoneType
safe_secstruct(...) from builtins.PyCapsule
safe_secstruct(self : rosetta.protocols.jumping.JumpSample, pose : rosetta.core.pose.Pose) -> NoneType
set_fold_tree_and_chainbreaks(...) from builtins.PyCapsule
set_fold_tree_and_chainbreaks(self : rosetta.protocols.jumping.JumpSample, pose : rosetta.core.pose.Pose) -> NoneType
set_fold_tree_in_pose(...) from builtins.PyCapsule
set_fold_tree_in_pose(self : rosetta.protocols.jumping.JumpSample, pose : rosetta.core.pose.Pose) -> NoneType
size(...) from builtins.PyCapsule
size(rosetta.protocols.jumping.JumpSample) -> int
steal_jumps(...) from builtins.PyCapsule
steal_jumps(self : rosetta.protocols.jumping.JumpSample, native_pose : rosetta.core.pose.Pose, begin : rosetta.core.fragment.FrameIterator, end : rosetta.core.fragment.FrameIterator) -> NoneType
steal_orientation_and_pleating(...) from builtins.PyCapsule
steal_orientation_and_pleating(self : rosetta.protocols.jumping.JumpSample, native_pose : rosetta.core.pose.Pose) -> NoneType
total_residue(...) from builtins.PyCapsule
total_residue(rosetta.protocols.jumping.JumpSample) -> int
transfer_jumps(...) from builtins.PyCapsule
transfer_jumps(self : rosetta.protocols.jumping.JumpSample, pose : rosetta.core.pose.Pose, native_pose : rosetta.core.pose.Pose) -> NoneType

 
class JumpSelector(BaseJumpSetup)
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
Method resolution order:
JumpSelector
BaseJumpSetup
builtins.object
Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(handle) -> NoneType
 
2. __init__(self : handle, ss : str) -> NoneType
 
3. __init__(handle, rosetta.protocols.jumping.JumpSelector) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
add_jump(...) from builtins.PyCapsule
add_jump(*args, **kwargs)
Overloaded function.
 
1. add_jump(self : rosetta.protocols.jumping.JumpSelector, jd : protocols::jumping::JumpSelector::JumpWeightDef) -> NoneType
 
2. add_jump(self : rosetta.protocols.jumping.JumpSelector, jump : rosetta.protocols.jumping.Interval, weight : float) -> NoneType
 
3. add_jump(self : rosetta.protocols.jumping.JumpSelector, js : int, je : int, weight : float) -> NoneType
assign(...) from builtins.PyCapsule
assign(self : rosetta.protocols.jumping.JumpSelector,  : rosetta.protocols.jumping.JumpSelector) -> rosetta.protocols.jumping.JumpSelector
begin(...) from builtins.PyCapsule
begin(rosetta.protocols.jumping.JumpSelector) -> __gnu_cxx::__normal_iterator<protocols::jumping::JumpSelector::JumpWeightDef const*, std::vector<protocols::jumping::JumpSelector::JumpWeightDef, std::allocator<protocols::jumping::JumpSelector::JumpWeightDef> > >
clean_jumps(...) from builtins.PyCapsule
clean_jumps(self : rosetta.protocols.jumping.JumpSelector, js : rosetta.protocols.jumping.JumpSample) -> rosetta.protocols.jumping.JumpSample
create_jump_sample(...) from builtins.PyCapsule
create_jump_sample(rosetta.protocols.jumping.JumpSelector) -> rosetta.protocols.jumping.JumpSample
end(...) from builtins.PyCapsule
end(rosetta.protocols.jumping.JumpSelector) -> __gnu_cxx::__normal_iterator<protocols::jumping::JumpSelector::JumpWeightDef const*, std::vector<protocols::jumping::JumpSelector::JumpWeightDef, std::allocator<protocols::jumping::JumpSelector::JumpWeightDef> > >
read_file(...) from builtins.PyCapsule
read_file(self : rosetta.protocols.jumping.JumpSelector, file : str) -> NoneType
select_random(...) from builtins.PyCapsule
select_random(rosetta.protocols.jumping.JumpSelector) -> rosetta.protocols.jumping.Interval
set_secstruct(...) from builtins.PyCapsule
set_secstruct(self : rosetta.protocols.jumping.JumpSelector, ss : str) -> NoneType
size(...) from builtins.PyCapsule
size(rosetta.protocols.jumping.JumpSelector) -> int
type_name(...) from builtins.PyCapsule
type_name(rosetta.protocols.jumping.JumpSelector) -> str
Methods inherited from BaseJumpSetup:
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.BaseJumpSetup,  : rosetta.protocols.jumping.JumpSample, mm : rosetta.core.kinematics.MoveMap) -> rosetta.core.fragment.FragSet
 
returns an ordered FragSet that is compatible with the JumpSample
 default: generate jumps from ss-library according to JumpSample

 
class JumpSetup(BaseJumpSetup)
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
Method resolution order:
JumpSetup
BaseJumpSetup
builtins.object
Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self : handle, total_residue : int) -> NoneType
 
2. __init__(handle, rosetta.protocols.jumping.JumpSetup) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
add_jump(...) from builtins.PyCapsule
add_jump(*args, **kwargs)
Overloaded function.
 
1. add_jump(self : rosetta.protocols.jumping.JumpSetup, jd : protocols::jumping::JumpSetup::JumpDef) -> NoneType
 
2. add_jump(self : rosetta.protocols.jumping.JumpSetup, jump : rosetta.protocols.jumping.Interval, cut_reg : rosetta.protocols.jumping.Interval) -> NoneType
 
3. add_jump(self : rosetta.protocols.jumping.JumpSetup, js : int, je : int, crs : int, cre : int) -> NoneType
assign(...) from builtins.PyCapsule
assign(self : rosetta.protocols.jumping.JumpSetup,  : rosetta.protocols.jumping.JumpSetup) -> rosetta.protocols.jumping.JumpSetup
begin(...) from builtins.PyCapsule
begin(rosetta.protocols.jumping.JumpSetup) -> __gnu_cxx::__normal_iterator<protocols::jumping::JumpSetup::JumpDef const*, std::vector<protocols::jumping::JumpSetup::JumpDef, std::allocator<protocols::jumping::JumpSetup::JumpDef> > >
clean_jumps(...) from builtins.PyCapsule
clean_jumps(self : rosetta.protocols.jumping.JumpSetup, js : rosetta.protocols.jumping.JumpSample) -> rosetta.protocols.jumping.JumpSample
clear(...) from builtins.PyCapsule
clear(rosetta.protocols.jumping.JumpSetup) -> NoneType
create_jump_sample(...) from builtins.PyCapsule
create_jump_sample(rosetta.protocols.jumping.JumpSetup) -> rosetta.protocols.jumping.JumpSample
end(...) from builtins.PyCapsule
end(rosetta.protocols.jumping.JumpSetup) -> __gnu_cxx::__normal_iterator<protocols::jumping::JumpSetup::JumpDef const*, std::vector<protocols::jumping::JumpSetup::JumpDef, std::allocator<protocols::jumping::JumpSetup::JumpDef> > >
read_file(...) from builtins.PyCapsule
read_file(self : rosetta.protocols.jumping.JumpSetup, file : str) -> NoneType
set_jump_sample(...) from builtins.PyCapsule
set_jump_sample(self : rosetta.protocols.jumping.JumpSetup, jump_sample : rosetta.protocols.jumping.JumpSample) -> NoneType
size(...) from builtins.PyCapsule
size(rosetta.protocols.jumping.JumpSetup) -> int
total_residue(...) from builtins.PyCapsule
total_residue(rosetta.protocols.jumping.JumpSetup) -> int
type_name(...) from builtins.PyCapsule
type_name(rosetta.protocols.jumping.JumpSetup) -> str
Methods inherited from BaseJumpSetup:
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.BaseJumpSetup,  : rosetta.protocols.jumping.JumpSample, mm : rosetta.core.kinematics.MoveMap) -> rosetta.core.fragment.FragSet
 
returns an ordered FragSet that is compatible with the JumpSample
 default: generate jumps from ss-library according to JumpSample

 
class JumpsFromAllPairings(BaseJumpSetup)
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
Method resolution order:
JumpsFromAllPairings
BaseJumpSetup
builtins.object
Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self : rosetta.protocols.jumping.JumpsFromAllPairings, total_residue : int, jumps : rosetta.utility.vector1_core_scoring_dssp_Pairing, cut_probability : ObjexxFCL::FArray1D<float>) -> NoneType
 
2. __init__(rosetta.protocols.jumping.JumpsFromAllPairings, rosetta.protocols.jumping.JumpsFromAllPairings) -> 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.protocols.jumping.JumpsFromAllPairings,  : rosetta.protocols.jumping.JumpsFromAllPairings) -> rosetta.protocols.jumping.JumpsFromAllPairings
create_jump_sample(...) from builtins.PyCapsule
create_jump_sample(rosetta.protocols.jumping.JumpsFromAllPairings) -> rosetta.protocols.jumping.JumpSample
Methods inherited from BaseJumpSetup:
clean_jumps(...) from builtins.PyCapsule
clean_jumps(self : rosetta.protocols.jumping.BaseJumpSetup,  : rosetta.protocols.jumping.JumpSample) -> rosetta.protocols.jumping.JumpSample
 
take from a given JumpSample only those Jumps, which could also have been created by create_jump_sample()
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.BaseJumpSetup,  : rosetta.protocols.jumping.JumpSample, mm : rosetta.core.kinematics.MoveMap) -> rosetta.core.fragment.FragSet
 
returns an ordered FragSet that is compatible with the JumpSample
 default: generate jumps from ss-library according to JumpSample
type_name(...) from builtins.PyCapsule
type_name(rosetta.protocols.jumping.BaseJumpSetup) -> str

 
class MembraneJump(builtins.object)
     Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(rosetta.protocols.jumping.MembraneJump) -> 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.protocols.jumping.MembraneJump,  : rosetta.protocols.jumping.MembraneJump) -> rosetta.protocols.jumping.MembraneJump
defined(...) from builtins.PyCapsule
defined(rosetta.protocols.jumping.MembraneJump) -> bool
init(...) from builtins.PyCapsule
init(self : rosetta.protocols.jumping.MembraneJump, template_file : str, pairings_file : str) -> NoneType
pairings_size(...) from builtins.PyCapsule
pairings_size(rosetta.protocols.jumping.MembraneJump) -> int
rt_templates(...) from builtins.PyCapsule
rt_templates(self : rosetta.protocols.jumping.MembraneJump, pose : rosetta.core.pose.Pose) -> NoneType
setup_fold_tree(...) from builtins.PyCapsule
setup_fold_tree(self : rosetta.protocols.jumping.MembraneJump, pose : rosetta.core.pose.Pose, njumps : int) -> NoneType
template_size(...) from builtins.PyCapsule
template_size(rosetta.protocols.jumping.MembraneJump) -> int

 
class PairingLibrary(BasePairingLibrary)
    
Method resolution order:
PairingLibrary
BasePairingLibrary
builtins.object
Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(handle) -> NoneType
 
2. __init__(handle, rosetta.protocols.jumping.PairingLibrary) -> 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.protocols.jumping.PairingLibrary,  : rosetta.protocols.jumping.PairingLibrary) -> rosetta.protocols.jumping.PairingLibrary
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.PairingLibrary, pairings : rosetta.utility.vector1_core_scoring_dssp_Pairing, mm : rosetta.core.kinematics.MoveMap, bWithTorsion : bool, frags_accumulator : rosetta.core.fragment.FragSet) -> NoneType
get_random_beta_sheet_jump(...) from builtins.PyCapsule
get_random_beta_sheet_jump(self : rosetta.protocols.jumping.PairingLibrary, orientation : int, pleating : int) -> rosetta.core.kinematics.RT
 
classic rosetta++ accessor
get_random_tmh_jump(...) from builtins.PyCapsule
get_random_tmh_jump(self : rosetta.protocols.jumping.PairingLibrary, orientation : int, pos1 : int, pos2 : int) -> rosetta.core.kinematics.RT
 
classic rosetta++ accessor
read_from_file(...) from builtins.PyCapsule
read_from_file(self : rosetta.protocols.jumping.PairingLibrary, fn : str) -> NoneType
read_from_file_no_filters(...) from builtins.PyCapsule
read_from_file_no_filters(self : rosetta.protocols.jumping.PairingLibrary, fn : str) -> NoneType
set_tmh_jump(...) from builtins.PyCapsule
set_tmh_jump(self : rosetta.protocols.jumping.PairingLibrary, pose : rosetta.core.pose.Pose, jump_number : int, orientation : int, pos1 : int, pos2 : int) -> NoneType
size(...) from builtins.PyCapsule
size(rosetta.protocols.jumping.PairingLibrary) -> int

 
class PairingTemplate(builtins.object)
     Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self : rosetta.protocols.jumping.PairingTemplate, c : str, s1 : str, s2 : str, s3 : str) -> NoneType
 
2. __init__(self : rosetta.protocols.jumping.PairingTemplate, s1 : str, s2 : str, s3 : str) -> NoneType
 
3. __init__(self : rosetta.protocols.jumping.PairingTemplate,  : rosetta.protocols.jumping.PairingTemplate) -> 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.protocols.jumping.PairingTemplate,  : rosetta.protocols.jumping.PairingTemplate) -> rosetta.protocols.jumping.PairingTemplate
Data descriptors defined here:
atoms_downstream_
atoms_upstream_
omega
phi
psi
rt_
secstruct

 
class RandomSheetBuilder(SheetBuilder)
    select jumps to build a given topology
 
 
this class encapsulates the functionality of choose_random_pairings in jumping_pairings.cc of Rosetta++
 
 
Method resolution order:
RandomSheetBuilder
SheetBuilder
BaseJumpSetup
builtins.object
Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self : handle,  : rosetta.core.fragment.SecondaryStructure,  : rosetta.utility.vector1_core_scoring_dssp_Pairing,  : rosetta.utility.vector1_unsigned_long) -> NoneType
 
2. __init__(handle, rosetta.protocols.jumping.RandomSheetBuilder) -> 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.protocols.jumping.RandomSheetBuilder,  : rosetta.protocols.jumping.RandomSheetBuilder) -> rosetta.protocols.jumping.RandomSheetBuilder
Methods inherited from SheetBuilder:
clean_jumps(...) from builtins.PyCapsule
clean_jumps(self : rosetta.protocols.jumping.SheetBuilder, js : rosetta.protocols.jumping.JumpSample) -> rosetta.protocols.jumping.JumpSample
create_jump_sample(...) from builtins.PyCapsule
create_jump_sample(rosetta.protocols.jumping.SheetBuilder) -> rosetta.protocols.jumping.JumpSample
total_residue(...) from builtins.PyCapsule
total_residue(rosetta.protocols.jumping.SheetBuilder) -> int
type_name(...) from builtins.PyCapsule
type_name(rosetta.protocols.jumping.SheetBuilder) -> str
Methods inherited from BaseJumpSetup:
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.BaseJumpSetup,  : rosetta.protocols.jumping.JumpSample, mm : rosetta.core.kinematics.MoveMap) -> rosetta.core.fragment.FragSet
 
returns an ordered FragSet that is compatible with the JumpSample
 default: generate jumps from ss-library according to JumpSample

 
class ResiduePairJump(builtins.object)
     Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.protocols.jumping.ResiduePairJump) -> NoneType
 
2. __init__(self : rosetta.protocols.jumping.ResiduePairJump, residue1 : rosetta.core.chemical.ResidueType, residue2 : rosetta.core.chemical.ResidueType) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
add_residue_pair(...) from builtins.PyCapsule
add_residue_pair(self : rosetta.protocols.jumping.ResiduePairJump, residue1 : rosetta.core.chemical.ResidueType, residue2 : rosetta.core.chemical.ResidueType) -> NoneType
add_residue_single(...) from builtins.PyCapsule
add_residue_single(self : rosetta.protocols.jumping.ResiduePairJump, residue : rosetta.core.chemical.ResidueType) -> NoneType
assign(...) from builtins.PyCapsule
assign(self : rosetta.protocols.jumping.ResiduePairJump,  : rosetta.protocols.jumping.ResiduePairJump) -> rosetta.protocols.jumping.ResiduePairJump
build_cst_conformer_jumps(...) from builtins.PyCapsule
build_cst_conformer_jumps(rosetta.protocols.jumping.ResiduePairJump) -> NoneType
build_sidechain_rotamers(...) from builtins.PyCapsule
build_sidechain_rotamers(rosetta.protocols.jumping.ResiduePairJump) -> NoneType
cstAtoms(...) from builtins.PyCapsule
cstAtoms(self : rosetta.protocols.jumping.ResiduePairJump, i : int) -> rosetta.utility.vector1_std_string
cstAtoms_defined(...) from builtins.PyCapsule
cstAtoms_defined(rosetta.protocols.jumping.ResiduePairJump) -> bool
cstInfoMap_defined(...) from builtins.PyCapsule
cstInfoMap_defined(rosetta.protocols.jumping.ResiduePairJump) -> bool
diversify_cst_conformers(...) from builtins.PyCapsule
diversify_cst_conformers(*args, **kwargs)
Overloaded function.
 
1. diversify_cst_conformers(self : rosetta.protocols.jumping.ResiduePairJump, type : rosetta.protocols.jumping.cstType, max_index : int) -> NoneType
 
2. diversify_cst_conformers(rosetta.protocols.jumping.ResiduePairJump) -> NoneType
diversify_dof_conformers(...) from builtins.PyCapsule
diversify_dof_conformers(*args, **kwargs)
Overloaded function.
 
1. diversify_dof_conformers(self : rosetta.protocols.jumping.ResiduePairJump, type : rosetta.protocols.jumping.dofType, max_index : int) -> NoneType
 
2. diversify_dof_conformers(rosetta.protocols.jumping.ResiduePairJump) -> NoneType
generate_frame(...) from builtins.PyCapsule
generate_frame(rosetta.protocols.jumping.ResiduePairJump) -> rosetta.core.fragment.Frame
init_mini_pose(...) from builtins.PyCapsule
init_mini_pose(rosetta.protocols.jumping.ResiduePairJump) -> NoneType
jumpAtoms(...) from builtins.PyCapsule
jumpAtoms(self : rosetta.protocols.jumping.ResiduePairJump, i : int) -> rosetta.utility.vector1_std_string
jumpAtoms_defined(...) from builtins.PyCapsule
jumpAtoms_defined(rosetta.protocols.jumping.ResiduePairJump) -> bool
set_cstAtoms(...) from builtins.PyCapsule
set_cstAtoms(self : rosetta.protocols.jumping.ResiduePairJump, rsd : int, atom : int, name : str) -> NoneType
set_cstInfo(...) from builtins.PyCapsule
set_cstInfo(*args, **kwargs)
Overloaded function.
 
1. set_cstInfo(self : rosetta.protocols.jumping.ResiduePairJump, type : rosetta.protocols.jumping.cstType, value : float) -> NoneType
 
2. set_cstInfo(self : rosetta.protocols.jumping.ResiduePairJump, type : rosetta.protocols.jumping.cstType, values : rosetta.utility.vector1_double) -> NoneType
set_jumpAtoms(...) from builtins.PyCapsule
set_jumpAtoms(self : rosetta.protocols.jumping.ResiduePairJump, rsd : int, atom : int, name : str) -> NoneType

 
class ResiduePairJumpSetup(BaseJumpSetup)
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
Method resolution order:
ResiduePairJumpSetup
BaseJumpSetup
builtins.object
Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(handle) -> NoneType
 
2. __init__(self : handle, total_residue : int) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
add_jump(...) from builtins.PyCapsule
add_jump(*args, **kwargs)
Overloaded function.
 
1. add_jump(self : rosetta.protocols.jumping.ResiduePairJumpSetup, jd : protocols::jumping::ResiduePairJumpSetup::JumpDef) -> NoneType
 
2. add_jump(self : rosetta.protocols.jumping.ResiduePairJumpSetup, jump : rosetta.protocols.jumping.Interval, cut_reg : rosetta.protocols.jumping.Interval) -> NoneType
 
3. add_jump(self : rosetta.protocols.jumping.ResiduePairJumpSetup, js : int, je : int, crs : int, cre : int) -> NoneType
add_residue_pair_jump(...) from builtins.PyCapsule
add_residue_pair_jump(self : rosetta.protocols.jumping.ResiduePairJumpSetup, ptr : rosetta.protocols.jumping.ResiduePairJump) -> NoneType
assign(...) from builtins.PyCapsule
assign(self : rosetta.protocols.jumping.ResiduePairJumpSetup,  : rosetta.protocols.jumping.ResiduePairJumpSetup) -> rosetta.protocols.jumping.ResiduePairJumpSetup
begin(...) from builtins.PyCapsule
begin(rosetta.protocols.jumping.ResiduePairJumpSetup) -> __gnu_cxx::__normal_iterator<protocols::jumping::ResiduePairJumpSetup::JumpDef const*, std::vector<protocols::jumping::ResiduePairJumpSetup::JumpDef, std::allocator<protocols::jumping::ResiduePairJumpSetup::JumpDef> > >
clean_jumps(...) from builtins.PyCapsule
clean_jumps(self : rosetta.protocols.jumping.ResiduePairJumpSetup, js : rosetta.protocols.jumping.JumpSample) -> rosetta.protocols.jumping.JumpSample
clear(...) from builtins.PyCapsule
clear(rosetta.protocols.jumping.ResiduePairJumpSetup) -> NoneType
create_jump_sample(...) from builtins.PyCapsule
create_jump_sample(rosetta.protocols.jumping.ResiduePairJumpSetup) -> rosetta.protocols.jumping.JumpSample
end(...) from builtins.PyCapsule
end(rosetta.protocols.jumping.ResiduePairJumpSetup) -> __gnu_cxx::__normal_iterator<protocols::jumping::ResiduePairJumpSetup::JumpDef const*, std::vector<protocols::jumping::ResiduePairJumpSetup::JumpDef, std::allocator<protocols::jumping::ResiduePairJumpSetup::JumpDef> > >
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.ResiduePairJumpSetup,  : rosetta.protocols.jumping.JumpSample, mm : rosetta.core.kinematics.MoveMap) -> rosetta.core.fragment.FragSet
read_file(...) from builtins.PyCapsule
read_file(self : rosetta.protocols.jumping.ResiduePairJumpSetup, file : str) -> NoneType
root(...) from builtins.PyCapsule
root(rosetta.protocols.jumping.ResiduePairJumpSetup) -> int
set_root(...) from builtins.PyCapsule
set_root(self : rosetta.protocols.jumping.ResiduePairJumpSetup, root : int) -> NoneType
size(...) from builtins.PyCapsule
size(rosetta.protocols.jumping.ResiduePairJumpSetup) -> int
total_residue(...) from builtins.PyCapsule
total_residue(rosetta.protocols.jumping.ResiduePairJumpSetup) -> int
type_name(...) from builtins.PyCapsule
type_name(rosetta.protocols.jumping.ResiduePairJumpSetup) -> str

 
class ResiduePairJumpSingle(builtins.object)
    ////////////////////////////////////////////////////////////////////////////////
 
 
 a single residue component of a ResiduePairJump class
 
 
 a residue type with information which atoms to be used to define a jump
and cst.
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.protocols.jumping.ResiduePairJumpSingle) -> NoneType
 
2. __init__(self : rosetta.protocols.jumping.ResiduePairJumpSingle, residue_type : rosetta.core.chemical.ResidueType) -> 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.protocols.jumping.ResiduePairJumpSingle,  : rosetta.protocols.jumping.ResiduePairJumpSingle) -> rosetta.protocols.jumping.ResiduePairJumpSingle
cstAtoms(...) from builtins.PyCapsule
cstAtoms(*args, **kwargs)
Overloaded function.
 
1. cstAtoms(rosetta.protocols.jumping.ResiduePairJumpSingle) -> rosetta.utility.vector1_std_string
 
access all three cstAtoms at once
 
2. cstAtoms(self : rosetta.protocols.jumping.ResiduePairJumpSingle, i : int) -> str
 
access single cstAtom one at a time
cstAtoms_defined(...) from builtins.PyCapsule
cstAtoms_defined(rosetta.protocols.jumping.ResiduePairJumpSingle) -> bool
 
have cstAtoms been defined?
fixResidue(...) from builtins.PyCapsule
fixResidue(rosetta.protocols.jumping.ResiduePairJumpSingle) -> bool
 
whether this residue has internal flexibility
jumpAtoms(...) from builtins.PyCapsule
jumpAtoms(*args, **kwargs)
Overloaded function.
 
1. jumpAtoms(rosetta.protocols.jumping.ResiduePairJumpSingle) -> rosetta.utility.vector1_std_string
 
access all three jumpAtoms at once
 
2. jumpAtoms(self : rosetta.protocols.jumping.ResiduePairJumpSingle, i : int) -> str
 
access single jumpAtom one at a time
jumpAtoms_defined(...) from builtins.PyCapsule
jumpAtoms_defined(rosetta.protocols.jumping.ResiduePairJumpSingle) -> bool
 
have jumpAtoms been defined?
residueType(...) from builtins.PyCapsule
residueType(rosetta.protocols.jumping.ResiduePairJumpSingle) -> rosetta.core.chemical.ResidueType
 
access residue type
set_cstAtoms(...) from builtins.PyCapsule
set_cstAtoms(*args, **kwargs)
Overloaded function.
 
1. set_cstAtoms(self : rosetta.protocols.jumping.ResiduePairJumpSingle, cst_atoms : rosetta.utility.vector1_std_string) -> NoneType
 
set all three cstAtoms at once
 
2. set_cstAtoms(self : rosetta.protocols.jumping.ResiduePairJumpSingle, i : int, atom_name : str) -> NoneType
 
set all single cstAtom one at a time
set_jumpAtoms(...) from builtins.PyCapsule
set_jumpAtoms(*args, **kwargs)
Overloaded function.
 
1. set_jumpAtoms(self : rosetta.protocols.jumping.ResiduePairJumpSingle, jump_atoms : rosetta.utility.vector1_std_string) -> NoneType
 
set all three jumpAtoms at once
 
2. set_jumpAtoms(self : rosetta.protocols.jumping.ResiduePairJumpSingle, i : int, atom_name : str) -> NoneType
 
set single jumpAtom one at a time

 
class SameStrand(builtins.object)
    tiny helper class that knows the relative fractions of secondary structure  L,H,E
 
 
 
so far these fractions can be computed from a FragSet
other input strategies are conceivable but not implemented, yet: eg. psipred files, a bunch of poses,
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self : rosetta.protocols.jumping.SameStrand,  : rosetta.core.fragment.SecondaryStructure) -> NoneType
 
2. __init__(self : rosetta.protocols.jumping.SameStrand,  : rosetta.protocols.jumping.SameStrand) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__str__(...) from builtins.PyCapsule
__str__(rosetta.protocols.jumping.SameStrand) -> str
assign(...) from builtins.PyCapsule
assign(self : rosetta.protocols.jumping.SameStrand,  : rosetta.protocols.jumping.SameStrand) -> rosetta.protocols.jumping.SameStrand
eval(...) from builtins.PyCapsule
eval(self : rosetta.protocols.jumping.SameStrand, i : int, j : int) -> bool
 
return whether residue i and j are on the same strand
redo(...) from builtins.PyCapsule
redo(rosetta.protocols.jumping.SameStrand) -> NoneType
 
new stochastic choices for strand boundaries
total_residue(...) from builtins.PyCapsule
total_residue(rosetta.protocols.jumping.SameStrand) -> int
 
...

 
class SheetBuilder(BaseJumpSetup)
    select jumps to build a given topology
 
 
this class encapsulates the functionality of choose_random_pairings in jumping_pairings.cc of Rosetta++
 
 
Method resolution order:
SheetBuilder
BaseJumpSetup
builtins.object
Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self : handle,  : rosetta.core.fragment.SecondaryStructure,  : rosetta.utility.vector1_core_scoring_dssp_Pairing,  : rosetta.utility.vector1_unsigned_long) -> NoneType
 
2. __init__(handle, rosetta.protocols.jumping.SheetBuilder) -> 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.protocols.jumping.SheetBuilder,  : rosetta.protocols.jumping.SheetBuilder) -> rosetta.protocols.jumping.SheetBuilder
clean_jumps(...) from builtins.PyCapsule
clean_jumps(self : rosetta.protocols.jumping.SheetBuilder, js : rosetta.protocols.jumping.JumpSample) -> rosetta.protocols.jumping.JumpSample
create_jump_sample(...) from builtins.PyCapsule
create_jump_sample(rosetta.protocols.jumping.SheetBuilder) -> rosetta.protocols.jumping.JumpSample
total_residue(...) from builtins.PyCapsule
total_residue(rosetta.protocols.jumping.SheetBuilder) -> int
type_name(...) from builtins.PyCapsule
type_name(rosetta.protocols.jumping.SheetBuilder) -> str
Methods inherited from BaseJumpSetup:
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.BaseJumpSetup,  : rosetta.protocols.jumping.JumpSample, mm : rosetta.core.kinematics.MoveMap) -> rosetta.core.fragment.FragSet
 
returns an ordered FragSet that is compatible with the JumpSample
 default: generate jumps from ss-library according to JumpSample

 
class SpecificGeometryLibrary(PairingLibrary)
    
Method resolution order:
SpecificGeometryLibrary
PairingLibrary
BasePairingLibrary
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.protocols.jumping.SpecificGeometryLibrary,  : rosetta.protocols.jumping.SpecificGeometryLibrary) -> rosetta.protocols.jumping.SpecificGeometryLibrary
Methods inherited from PairingLibrary:
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.PairingLibrary, pairings : rosetta.utility.vector1_core_scoring_dssp_Pairing, mm : rosetta.core.kinematics.MoveMap, bWithTorsion : bool, frags_accumulator : rosetta.core.fragment.FragSet) -> NoneType
get_random_beta_sheet_jump(...) from builtins.PyCapsule
get_random_beta_sheet_jump(self : rosetta.protocols.jumping.PairingLibrary, orientation : int, pleating : int) -> rosetta.core.kinematics.RT
 
classic rosetta++ accessor
get_random_tmh_jump(...) from builtins.PyCapsule
get_random_tmh_jump(self : rosetta.protocols.jumping.PairingLibrary, orientation : int, pos1 : int, pos2 : int) -> rosetta.core.kinematics.RT
 
classic rosetta++ accessor
read_from_file(...) from builtins.PyCapsule
read_from_file(self : rosetta.protocols.jumping.PairingLibrary, fn : str) -> NoneType
read_from_file_no_filters(...) from builtins.PyCapsule
read_from_file_no_filters(self : rosetta.protocols.jumping.PairingLibrary, fn : str) -> NoneType
set_tmh_jump(...) from builtins.PyCapsule
set_tmh_jump(self : rosetta.protocols.jumping.PairingLibrary, pose : rosetta.core.pose.Pose, jump_number : int, orientation : int, pos1 : int, pos2 : int) -> NoneType
size(...) from builtins.PyCapsule
size(rosetta.protocols.jumping.PairingLibrary) -> int

 
class StandardDisulfPairingLibrary(DisulfPairingLibrary)
    The %StandardDisulfPairingsLibrary initializes itself in its constructor
from the sampling/disulfide_jump_database_wip.dat file in the database.  Users
should not in any circumstance invoke any of its non-const methods that are defined
in the subclass.  This class ought to be reworked to ensure that it is threadsafe.
 
 
Method resolution order:
StandardDisulfPairingLibrary
DisulfPairingLibrary
BaseDisulfPairingLibrary
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.
Methods inherited from DisulfPairingLibrary:
assign(...) from builtins.PyCapsule
assign(self : rosetta.protocols.jumping.DisulfPairingLibrary,  : rosetta.protocols.jumping.DisulfPairingLibrary) -> rosetta.protocols.jumping.DisulfPairingLibrary
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.DisulfPairingLibrary, pairings : rosetta.utility.vector1_protocols_jumping_DisulfPairing, mm : rosetta.core.kinematics.MoveMap, bWithTorsion : bool, frags_accumulator : rosetta.core.fragment.FragSet) -> NoneType
read_from_file(...) from builtins.PyCapsule
read_from_file(self : rosetta.protocols.jumping.DisulfPairingLibrary, fn : str) -> NoneType
size(...) from builtins.PyCapsule
size(rosetta.protocols.jumping.DisulfPairingLibrary) -> int

 
class StandardPairingLibrary(PairingLibrary)
    This class is thread-unsafe, though, if perhaps none of its non-const
functions were accessible, then it wouldn't be.
 
 
Method resolution order:
StandardPairingLibrary
PairingLibrary
BasePairingLibrary
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.
Methods inherited from PairingLibrary:
assign(...) from builtins.PyCapsule
assign(self : rosetta.protocols.jumping.PairingLibrary,  : rosetta.protocols.jumping.PairingLibrary) -> rosetta.protocols.jumping.PairingLibrary
generate_jump_frags(...) from builtins.PyCapsule
generate_jump_frags(self : rosetta.protocols.jumping.PairingLibrary, pairings : rosetta.utility.vector1_core_scoring_dssp_Pairing, mm : rosetta.core.kinematics.MoveMap, bWithTorsion : bool, frags_accumulator : rosetta.core.fragment.FragSet) -> NoneType
get_random_beta_sheet_jump(...) from builtins.PyCapsule
get_random_beta_sheet_jump(self : rosetta.protocols.jumping.PairingLibrary, orientation : int, pleating : int) -> rosetta.core.kinematics.RT
 
classic rosetta++ accessor
get_random_tmh_jump(...) from builtins.PyCapsule
get_random_tmh_jump(self : rosetta.protocols.jumping.PairingLibrary, orientation : int, pos1 : int, pos2 : int) -> rosetta.core.kinematics.RT
 
classic rosetta++ accessor
read_from_file(...) from builtins.PyCapsule
read_from_file(self : rosetta.protocols.jumping.PairingLibrary, fn : str) -> NoneType
read_from_file_no_filters(...) from builtins.PyCapsule
read_from_file_no_filters(self : rosetta.protocols.jumping.PairingLibrary, fn : str) -> NoneType
set_tmh_jump(...) from builtins.PyCapsule
set_tmh_jump(self : rosetta.protocols.jumping.PairingLibrary, pose : rosetta.core.pose.Pose, jump_number : int, orientation : int, pos1 : int, pos2 : int) -> NoneType
size(...) from builtins.PyCapsule
size(rosetta.protocols.jumping.PairingLibrary) -> int

 
class cstType(builtins.object)
     Methods defined here:
__eq__(...) from builtins.PyCapsule
__eq__(rosetta.protocols.jumping.cstType, rosetta.protocols.jumping.cstType) -> bool
__hash__(...) from builtins.PyCapsule
__hash__(rosetta.protocols.jumping.cstType) -> int
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.protocols.jumping.cstType, int) -> NoneType
 
2. __init__(rosetta.protocols.jumping.cstType, int) -> NoneType
__int__(...) from builtins.PyCapsule
__int__(rosetta.protocols.jumping.cstType) -> int
__ne__(...) from builtins.PyCapsule
__ne__(rosetta.protocols.jumping.cstType, rosetta.protocols.jumping.cstType) -> bool
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__repr__(...) from builtins.PyCapsule
__repr__(rosetta.protocols.jumping.cstType) -> str
Data and other attributes defined here:
angleA = cstType.angleA
angleB = cstType.angleB
dihedralA = cstType.dihedralA
dihedralAB = cstType.dihedralAB
dihedralB = cstType.num_cstType
disAB = cstType.disAB
num_cstType = cstType.num_cstType

 
class dofType(builtins.object)
     Methods defined here:
__eq__(...) from builtins.PyCapsule
__eq__(rosetta.protocols.jumping.dofType, rosetta.protocols.jumping.dofType) -> bool
__hash__(...) from builtins.PyCapsule
__hash__(rosetta.protocols.jumping.dofType) -> int
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.protocols.jumping.dofType, int) -> NoneType
 
2. __init__(rosetta.protocols.jumping.dofType, int) -> NoneType
__int__(...) from builtins.PyCapsule
__int__(rosetta.protocols.jumping.dofType) -> int
__ne__(...) from builtins.PyCapsule
__ne__(rosetta.protocols.jumping.dofType, rosetta.protocols.jumping.dofType) -> bool
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__repr__(...) from builtins.PyCapsule
__repr__(rosetta.protocols.jumping.dofType) -> str
Data and other attributes defined here:
cstJump = dofType.num_dofType
num_dofType = dofType.num_dofType
rot1 = dofType.rot1
rot2 = dofType.rot2

 
Functions
       
assign_ss_dssp(...) method of builtins.PyCapsule instance
assign_ss_dssp(pose : rosetta.core.pose.Pose) -> NoneType
 
Assign secondary structure using DSSP.
close_chainbreaks(...) method of builtins.PyCapsule instance
close_chainbreaks(*args, **kwargs)
Overloaded function.
 
1. close_chainbreaks(closure_protocol : rosetta.protocols.loops.loop_closure.ccd.SlidingWindowLoopClosure, pose : rosetta.core.pose.Pose, checkpoint : rosetta.protocols.checkpoint.CheckPointer, decoy_tag : str) -> NoneType
 
2. close_chainbreaks(closure_protocol : rosetta.protocols.loops.loop_closure.ccd.SlidingWindowLoopClosure, pose : rosetta.core.pose.Pose, checkpoint : rosetta.protocols.checkpoint.CheckPointer, decoy_tag : str, final_fold_tree : rosetta.core.kinematics.FoldTree) -> NoneType
generate_empty_jump_frame(...) method of builtins.PyCapsule instance
generate_empty_jump_frame(startpos : int, endpos : int, length : int) -> rosetta.core.fragment.JumpingFrame
generate_jump_frame(...) method of builtins.PyCapsule instance
generate_jump_frame(startpos : int, endpos : int, bWithTorsion : bool) -> rosetta.core.fragment.JumpingFrame
get_pairing_geometry(...) method of builtins.PyCapsule instance
get_pairing_geometry(pose : rosetta.core.pose.Pose, res1 : int, res2 : int, orientation : float, pleating1 : float, pleating2 : float) -> NoneType
get_pleating(...) method of builtins.PyCapsule instance
get_pleating(pose : rosetta.core.pose.Pose, pos1 : int, pos2 : int, orientation : int, pleating : int) -> NoneType
remove_cut(...) method of builtins.PyCapsule instance
remove_cut(*args, **kwargs)
Overloaded function.
 
1. remove_cut(cutpoint : int, pose : rosetta.core.pose.Pose) -> bool
 
2. remove_cut(cutpoint : int, pose : rosetta.core.pose.Pose, final_fold_tree : rosetta.core.kinematics.FoldTree) -> bool
 
3. remove_cut(cutpoint : int, fold_tree : rosetta.core.kinematics.FoldTree) -> bool
 
4. remove_cut(cutpoint : int, fold_tree : rosetta.core.kinematics.FoldTree, final_fold_tree : rosetta.core.kinematics.FoldTree) -> bool
safe_secstruct(...) method of builtins.PyCapsule instance
safe_secstruct(pose : rosetta.core.pose.Pose) -> NoneType

 
Data
        angleA = cstType.angleA
angleB = cstType.angleB
cstJump = dofType.num_dofType
dihedralA = cstType.dihedralA
dihedralAB = cstType.dihedralAB
dihedralB = cstType.num_cstType
disAB = cstType.disAB
num_cstType = cstType.num_cstType
num_dofType = dofType.num_dofType
rot1 = dofType.rot1
rot2 = dofType.rot2