rosetta.protocols.jd2.archive._protocols_jd2_archive_.AbstractArchiveBase:
Tags used to tag messeges sent by MPI functions used to decide
whether a slave is requesting a new job id or flagging as job as
being a bad input This job distributor is meant for running jobs
where the machine you are using has a large number of processors,
the number of jobs is much greater than the number of processors,
or the runtimes of the individual jobs could vary greatly.
rosetta.protocols.jd2.archive._protocols_jd2_archive_.EvaluatedArchive:
Tags used to tag messeges sent by MPI functions used to decide
whether a slave is requesting a new job id or flagging as job as
being a bad input This job distributor is meant for running jobs
where the machine you are using has a large number of processors,
the number of jobs is much greater than the number of processors,
or the runtimes of the individual jobs could vary greatly.
rosetta.protocols.jd2.archive._protocols_jd2_archive_.NormalizedEvaluatedArchive:
Tags used to tag messeges sent by MPI functions used to decide
whether a slave is requesting a new job id or flagging as job as
being a bad input This job distributor is meant for running jobs
where the machine you are using has a large number of processors,
the number of jobs is much greater than the number of processors,
or the runtimes of the individual jobs could vary greatly.
rosetta.core.chemical._core_chemical_.AcceptorAtomFilter:
/////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
The filter responsible for obtaining all acceptor atoms.
rosetta.protocols.anchored_design._protocols_anchored_design_.Anchor:
Anchor class provides for the "anchor" part of a scaffold
in anchored interface design Anchor class implements the code to
read in an anchor file, stores the definition of the anchor, and
provides access methods for setting move maps.
rosetta.core.chemical._core_chemical_.AromaticAtomFilter:
/////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
The filter responsible for all aromatic atoms.
rosetta.core.conformation._core_conformation_.Atom:
This atom class differs from the chameical::Atom, AtomType, and
AtomTypeSet classes in that it only contains the information about
the xyz coordinates.
rosetta.protocols.jd2.archive._protocols_jd2_archive_.BaseArchiveManager:
ArchiveManager is responsible for communication with JobDistributor
and organization of Batches and returning decoys @detail he owns an
Archive (AbstractArchiveBase) that will be handed the decoys and is
asked to generate_batch() if the QUEUE_EMPTY .
rosetta.protocols.jd2.archive._protocols_jd2_archive_.ArchiveManager:
ArchiveManager is responsible for communication with JobDistributor
and organization of Batches and returning decoys @detail he owns an
Archive (AbstractArchiveBase) that will be handed the decoys and is
asked to generate_batch() if the QUEUE_EMPTY .
rosetta.protocols.jd2.archive._protocols_jd2_archive_.Batch:
a Batch represents a directory "batch_000xxx" that contains flags, broker-setup input-files and output-files
@detail the Batch-class helps to get the correct file- and directory names,
and has some knowledge about its status: finished, unfinished ...
rosetta.protocols.forge.build._protocols_forge_build_'.Bridge:
connect two contiguous but disjoint sections of a Pose into one
continuous section
Anchor residues [i,j] to bridge must be adjacent to each other in the
Pose (i+1 = j) and adjacent to a cutpoint.
rosetta.core.scoring.carbohydrates._core_scoring_carbohydrates_.CHIEnergyFunction:
This is an implementation of the "CarboHydrate Intrinsic"
(CHI) energy function developed by Woods Lab.\n The Gaussian
parameters for the function depend on whether the glycosidic bond
in question is a phi or psi angle.\n The parameters further depend
on if the phi angles are at alpha or beta linkages and on if the
psi angles are at ->2-axial, ->3-equatorial, or ->4-axial
OR ->2-equatorial, ->3-axial, or ->4-equatorial
linkages.\n The function has not been developed for ->6 linkages
(with omega angles).
rosetta.core.scoring.hbonds._core_scoring_hbonds_.HBondSet:
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
A class that holds Hbond objects and helps setup Hbonds for scoring
rosetta.core.scoring._core_scoring_.MembraneEmbed:
/////////////////////////////// Membrane Embedding ///////////////////////////////////
Whole Pose Membrane Embedding
Define the embedding of the membrane pose based on computed
normal and center parameters.
rosetta.core.optimization._core_optimization_.ConvergenceTest:
************************************************ * * Rough outline
of how to structure this: * * Make a base 'minimizer' class * *
Sub-class into univariate and multivariate minimizers * ->
actually, could we treat linmin as an instance of multivariate *
minimization, with a single pass of steepest descent * * The trick
is how to mix and match convergence criteria, descent * direction
generation, and line minimization schemes * * convergence criteria
could be a function or a functor.
rosetta.core.scoring._core_scoring_.MinimizationEdge:
Class MinimizationEdge holds ResPairMinimizationData for a certain
pair of interacting residues; this data might be a neighborlist for
this residue pair, for example.
rosetta.core.chemical._core_chemical_.ElementSet:
A set of Bcl Elements This class contains a vector of pointers each
of which points to an Element and the vector index is looked up by
an element_name string in a map.
rosetta.basic._basic_.Emitter:
Lightweight class to ease writting YAML documents (http://yaml.org)
YAML is a structured data format, a more human-readable
alternative to XML.
rosetta.basic._basic_.JsonEmitter:
///////////////////////////////////////////////////////////////////////////
Lightweight class to ease writting JSON documents, a subset of YAML (http://json.org)
Using this class is not recommended -- use YamlEmitter instead.
rosetta.basic._basic_.YamlEmitter:
///////////////////////////////////////////////////////////////////////////
Emitter for more classically formatted YAML
rosetta.core.scoring.methods.carbohydrates._core_scoring_methods_carbohydrates_.SugarBackboneEnergy:
This class makes use of the "CarboHydrate Intrinsic"
(CHI) energy function developed by Woods Lab.\n Carbohydrate phi
angles are scored based on whether they are at alpha or beta
linkages.\n Psi angles are scored based on whether they are at
->2-axial, ->3-equatorial, or ->4-axial OR
->2-equatorial, ->3-axial, or ->4-equatorial linkages.\n
->6 linkages (with omega angles) are not scored.
rosetta.core.scoring.methods._core_scoring_methods_.EnergyMethodOptions:
add more options here NOTE: If you add an option, make sure you
also update the constructor, the assignment operator, the ==
comparison operator, and the show method in the .cc file! right now
this class should be pretty light-weight since a copy is held
inside ScoreFunctionInfo
rosetta.numeric.expression_parser._numeric_expression_parser_.Expression:
////////////////////////////////////////
// END ABSTRAT SYNTAX TREE CLASSES /////
////////////////////////////////////////
Pure virtual base class to define arbitrary expressions for
scripting arithmetic operations (e.g.
rosetta.core.scoring.hbonds._core_scoring_hbonds_.FadeInterval:
//////////////////////////
Classic FadeInterval
//////////////////////////
stores an "fading interval" [a b c d] with a <= b <= c <= d
and computes the fraction of containment for x, which is defined to be
0 if x is outside of (a,d), 1 if x is inside of [b,c],
and a linear ramp otherwise.
rosetta.basic.resource_manager._basic_resource_manager_.FallbackConfiguration:
The %FallbackConfiguration class describes how a resource should be
created if the ResourceManager is not being used, i.e., if
resources have been specified through flags on the command line
instead of through a resource-definition file.
rosetta.protocols.analysis._protocols_analysis_.PeptideDeriverFilter:
implementation of the Peptiderive protocol - given a pose, it
evaluates the binding energy of linear stretches, of given lengths,
and indicates which of these contributes more than others to the
interaction energy.
rosetta.protocols.simple_filters._protocols_simple_filters_.Sigmoid:
transform the output from a regular filter into a sigmoid ranging
from 0-1 according to: fx = 1/[1 + exp[ ( x - offset ) * steepness
] The function asymptotically reaches 1 at negative values and 0 at
positive values.
rosetta.protocols.frag_picker._protocols_frag_picker_.FragmentCandidate:
Vector candidate says which X-mer from vall fits to a query
sequence Scores for a given fragment are stored separately in a
FragmentScoreMap object Therefore fragment containers hold
std::pair<FragmentCandidateOP,FragmentScoreMapOP>
rosetta.core.fragment._core_fragment_.Frame:
Frame couples a list of FragData-instances to a certain alignment frame, i.e., position in sequence space
@detail A frame may be continous, i.e., its fragment data will be applied to all residues between start() and end()
or ( in a specialized version inheriting this interface) may contain a loose list of sequence positions.
rosetta.core.fragment._core_fragment_.NonContinuousFrame:
JumpingFrame is a discontinuous frame i.e, the SRFDs stored in the
FragData objects can be applied to residues anywhere a 5 7 9 Frame
of a FragData containing three BBTorsionSRFDs would change torsions
of 5 7 9 a 5 32 2 Frame of a FragData containing two BBTorsionSRFD
and on JumpSRFD would change torsions of 5 and 32 and the RT of
jump_nr 2 note that in the latter case the 2 is not coding for a
residue number! what is meaning of start() and end() ? If some of
the positions are actually jump_nr should we ignore them for the
start() / end() question ? or should we store which positions are
jumps and translate into residue numbers from jump_nr ? could a
MixedFrame contain Frames MixedFrame -- > non-cont-Frame,
JumpFrame
rosetta.core.scoring.func._core_scoring_func_.Func:
Func is an abstract base class representing a function used to
define constraints, in which func(r) gives the constraint score for
the given value r.
rosetta.core.scoring._core_scoring_.MinimizationGraph:
Class to hold all the minimization-specific data that's required to
efficiently evaluate the score function and its derivatives on a
structure of fixed sequence and chemical identity.
rosetta.core.chemical._core_chemical_.HeavyAtomWithPolarHydrogensFilter:
/////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
The filter responsible for obtaining all heavy atoms with polar hydrogens attached to them.
rosetta.protocols.jumping._protocols_jumping_.Interval:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
two numbers, i.e., jump start end residue, or cut-regions...
rosetta.protocols.jd2.archive._protocols_jd2_archive_.MPIArchiveJobDistributor:
Tags used to tag messeges sent by MPI functions used to decide whether a slave is requesting a new job id or
flagging as job as being a bad input
JobDistributor for the iterative ArchiveManager/Archive Framework
This job distributor is meant for running iterative jobs with the ArchiveManager/Archive Framework.
rosetta.protocols.jd2._protocols_jd2_.MPIWorkPartitionJobDistributor:
This job distributor is meant for running jobs where the number of
jobs is equal to the number of processors (or, similarly, the jobs
% processors calculation is very close to the number of processors
and NOT a small number).
rosetta.protocols.jd2._protocols_jd2_.MPIWorkPoolJobDistributor:
This job distributor is meant for running jobs where the machine
you are using has a large number of processors, the number of jobs
is much greater than the number of processors, or the runtimes of
the individual jobs could vary greatly.
rosetta.protocols.jd2._protocols_jd2_.JobInputter:
the JobInputter class is responsible for A) determining what jobs
exist, and B) taking a job object and returning the starting pose
associated with that job.
rosetta.protocols.jd2._protocols_jd2_.JD2ResourceManagerJobInputter:
See the documentation in the JD2ResourceManager for a description
of the file format for the ResourceLocators block
(JD2ResourceManager::read_resource_locators_tags), the
ResourceOptions block
(JD2ResourceManager::read_resource_options_tags) and the Resources
block (JD2ResourceManager::read_resources_tags).
rosetta.protocols.jd2._protocols_jd2_.JobOutputter:
the JobOutputter class is responsible for dealing with output, as
well as determining what jobs have already been output and what
sort of name is associated with a job.
rosetta.core.kinematics._core_kinematics_.Jump:
an object which makes rigid-body transformation with translational
and rotational perturbation See @ref atomtree_overview
"AtomTree overview and concepts" for details.
rosetta.protocols.toolbox._protocols_toolbox_.GreedyKCenter:
Greedy K-Center Clustering Algorithm "A Fast Geometric
Clustering Method on Conformation Space of Biomolecules" Jian
Sun, Yuan Yao, Xuhui Huang, Vijay Pande, Gunnar Carlsson, Leonidas
J.
rosetta.protocols.loops.loops_definers._protocols_loops_loops_definers_.LoopsDatabaseDefiner:
@ details given a database table with the following schema,
defining a single loop per row CREATE TABLE loops ( tag TEXT, start
INTEGER, stop INTEGER, cut INTEGER, skip_rate REAL, extended
BOOLEAN); return all loops associated with the job distributor
input tag Note: you can specify a different table using the
'database_table' field Note: if you would like to query the
database for loops differently, you can either pre-query the table
and store it, or extend, subclass, or create a different
LoopsDefiner class.
rosetta.core.chemical._core_chemical_.MMAtomTypeSet:
A set of MMAtomTypes This class contains a vector of pointers each
of which points to an MMAtomType and the vector index is looked up
by an atom_name string in a map.
rosetta.protocols.match.output._protocols_match_output_.DownstreamRMSEvaluator:
In the best of all possible worlds, this class would be
sufficiently generic such that I could compare RMS for arbitrary
subsets of atoms on the downstream partner, but in my first pass
implementation, I'm writing while aiming at the RigidLigandBuilder
-- 1 residue -- and I'll compare all heavy atoms.
rosetta.protocols.match._protocols_match_.TaskOperationMPM:
mpm that will get a task operation as specified in the tag from the
TaskOperationFactory, apply the task operation to the pose and
every residue that is then set to designing in the task will be a
match position
rosetta.core.kinematics._core_kinematics_.MoveMap:
A class specifying DOFs to be flexible or fixed
currently there are two groups of data, one is residue-based Torsion
definition, such as BB, CHI, NU, and JUMP; the other is atom-based DOF
definition, such as bond length D, bond angle THETA and torsion angle PHI
which are used in atom-tree.
rosetta.protocols.simple_moves._protocols_simple_moves_.ConstrainToIdealMover:
///////////////WARNING WARNING
WARNING////////////////////////////////////////////////////
Idealization is generally performed by adding constraints to the
Pose that keep bond lengths and angles within the appropriate
ranges; then freeing those DOFs and performing minimization or
sampling.
rosetta.protocols.grafting._protocols_grafting_.CCDEndsGraftMover:
General purpose Grafting class which:
1) superimposes the insert onto the scaffold using any overhang residues,
2) Inserts the pose piece into the scaffold pose, deleting any overhang residues or residues in the region the isertion will occur between.
rosetta.protocols.simple_moves._protocols_simple_moves_.WobbleMover:
A protocols::moves::Mover class for a classic-wobble analog: a smooth move followed by ccd closure
@detail a smooth fragment is chosen according to the FragmentCost Functor;
a cutpoint is inserted just in front of or just after the fragment
a loop is defined around the fragment and cutpoint to be closed with ccd:
a cut_Cterm insertion: ----lfff bbb---- f: fragment_res b: buffer_res -: immovable residues
a !cut_Cterm insertion: ---bbb fffl---
the number of b resiudes is controlled by buffer_length_ (default 3);
the move is used by apply() (inherited from FragmentMover).
rosetta.protocols.simple_moves._protocols_simple_moves_.MinMover:
////////////////////////////////////////////////////////////////////////////
A protocols::moves::Mover that minimizes a Pose to a local energy minimum by
performing energy minimization of a ScoreFunction over the allowable
degrees of freedom, defined by a MoveMap.
rosetta.protocols.relax._protocols_relax_.ClassicRelax:
A functor class which implements the classic Rosetta++ pose_relax
protocol @todo Crank and Wobble Moves - however there's little
evidence that they are essential A functor class which implements
the classic Rosetta++ pose_relax protocol
rosetta.protocols.simple_moves._protocols_simple_moves_.ShearMover:
////////////////////////////////////////////////////////////////////////////
A mover that perturbs the phi of residue i and the psi of residue
i-1 such that they create a 'shearing' effect, minimizing the downstream
consequences of this torsional perturbation.
rosetta.protocols.rigid._protocols_rigid_.RigidBodyPerturbNoCenterMover:
does a perturbation defined by the rotational and translational
magnitudes without setting up the center Can be defined through a
move map or with rb_jump Defining through a movemap with multiple
jumps leads to a random jump being chosen at apply time, NOT at
construction time! This is done to simplify docking with more than
one active jump.
rosetta.protocols.membrane._protocols_membrane_.TransformIntoMembraneMover:
Takes a pose, calculates the best possible center and normal from
the topology object (through spanfile from OCTOPUS) and the
coordinates of the pose CAUTION: THIS MOVER ONLY WORKS FOR A FIXED
MEMBRANE WHERE THE MEMBRANE VIRTUAL RESIDUE IS AT THE ROOT OF THE
FOLDTREE!!!
rosetta.core.scoring._core_scoring_.EnergyNode:
Class EnergyNode holds the result of a domainmap update from the
Conformation object held by a pose; if the internal degrees of
freedom for a residue (corresponding to a node in this graph) have
changed (and are marked with color "0" in the domainmap),
then the EnergyNode object will hold that information for the
ScoringFunction to retrieve
rosetta.core.pack.task._core_pack_task_.PackerTask_:
//////////////////////////////////////////////////////////////////////////
the PackerTask controls what rotameric (including sequence) changes
the packer is allowed to make
rosetta.core.chemical._core_chemical_.Patch:
/////////////////////////////////////////////////////////////////////////////////////
A class patching basic ResidueType to create variant types,
containing multiple PatchCase
rosetta.core.chemical._core_chemical_.PatchOperation:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
A single operation that needs to be applied in a residue patch
rosetta.core.chemical._core_chemical_.AddBond:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
add a bond to ResidueType
rosetta.core.chemical._core_chemical_.AddBondType:
////////////////////////////////////////////////////////////////////////////
A patch operation for adding a specific type of bond to a
ResidueType.
rosetta.core.chemical._core_chemical_.AddChi:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Add a chi angle to ResidueType.
rosetta.core.chemical._core_chemical_.AddChiRotamer:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Add a rotamer sample to a chi angle of the ResidueType.
rosetta.core.chemical._core_chemical_.AddProperty:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
add a property to ResidueType
rosetta.core.chemical._core_chemical_.DeleteProperty:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
delete a property from ResidueType
Added by Andy M.
rosetta.core.chemical._core_chemical_.NCAARotLibPath:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
set the path to a rotamer library for an NCAA that is not in
dunbrack
rosetta.core.chemical._core_chemical_.RedefineChi:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Redefine a chi angle
Added by Andy M.
rosetta.core.chemical._core_chemical_.SetICoor:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
set an atom's AtomICoord
rosetta.core.chemical._core_chemical_.SetNbrAtom:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
set the residue neighbor atom
rosetta.core.chemical._core_chemical_.SetNbrRadius:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
set the residue neighbor radius
rosetta.protocols.analysis._protocols_analysis_.PeptideDeriverOutputter:
an abstract base class for handling calculation outputs from
PeptideDeriverFilter
Since PeptideDeriverFilter might have a set of outputs for each residue,
for each chain in each chain-pair, outputting is quite elaborate.
rosetta.core.chemical._core_chemical_.PolarHydrogenFilter:
/////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
The filter responsible for all polar hydrogens.
rosetta.core.pose._core_pose_.Pose:
A molecular system including residues, kinematics, and energies
The Pose class represents a molecular system (protein-dna-ligand...)
as a container of Rosetta Residue objects together with
a Conformation object that defines how internal coordinate changes
propagate through the system and an Energies object that stores
information from the last energy evaluation.
rosetta.protocols.rotamer_recovery._protocols_rotamer_recovery_.RRComparer:
The comparison functionality for the rotamer recovery test Besides
implementing the interface given in the base class RRComparer each
RRComparer should have an entry in the conevience RotamerRecovery
constructor so its use can be indicated by name.
rosetta.protocols.rotamer_recovery._protocols_rotamer_recovery_.RRProtocol:
The protocol to run to compute the rotamer recovery the rotamer
recovery test Besides implementing the interface given in the base
class RRProtocol each RRProtocol should have an entry in the
convenience RotamerRecovery constructor so its use can be indicated
by name.
rosetta.protocols.rotamer_recovery._protocols_rotamer_recovery_.RRReporter:
The reporting functionality for the rotamer recovery test Besides
implementing the interface given in the base class RRReporter each
RRReporter should have an entry in the conevience RotamerRecovery
constructor so its use can be indicated by name.
rosetta.core.io.raw_data._core_io_raw_data_.RawFileData:
Abstract base class for classes that writes different types of
silent-files that contain a mixture of Struct objects which are
expected to be uniquely identified by some sort of string-based
tag.
rosetta.core.pack.task._core_pack_task_.AUTO:
AUTO suggests that a packer can/should reconsider the design
setting at a/each residue This is a protocol-level flag to be used
in non-vanilla packers.
rosetta.core.pack.task._core_pack_task_.NO_ADDUCTS:
NO_ADDUCTS will disable adducts, assuming they exist This command
exists because if adducts exist, then they are enabled by default
for all residues.
rosetta.core.pack.task._core_pack_task_.SCAN:
SCAN suggests to some packing routines that if there are multiple
type choices for this residue, then each of them should be
considered explicitly in one way or another This is a
protocol-level flag to be used in non-vanilla packers ashworth
rosetta.core.kinematics._core_kinematics_.ResidueCoordinateChangeList:
The AtomTree is responsible for informing the conformation of which
residues have had either internal (DOF) or external (xyz)
coordinate changes so that the Conformation may shuttle O(k) --
output sensitive -- data from the AtomTree to the Residue objects
it manages.
rosetta.core.pack.task.residue_selector._core_pack_task_residue_selector_.InterGroupInterfaceByVectorSelector:
The %InterGroupInterfaceByVectorSelector identifies residues at the
interface between two groups of residues using two distance
cutoffs: the first, shorter cutoff is based on atom-atom distances,
the second, longer cutoff is used if the c-alpha/c-beta vector of
the residues in the first group point toward the c-alphas of the
other group.
rosetta.core.chemical._core_chemical_.Selector_CMDFLAG:
/////////////////////////////////////////////////////////////////////////////////////
Is a certain string in the command-line option
-chemical:allow_patch present ? this selector does actually not
depend on the residuetype it is queried for
rosetta.core.chemical._core_chemical_.Selector_UPPER_POSITION:
/////////////////////////////////////////////////////////////////////////////////////
Does the main chain of this residue follow from the given position
label? By position, it is meant the single digit integer by which
atoms are labeled to indicate their position.
rosetta.core.chemical._core_chemical_.ResidueType:
A class for defining a type of residue This class contains the
"chemical" information for residues as well as the ideal
xyz and internal coordinates for a residue (generated xyz
coordinates are found in core/conformation/Residue.hh).
rosetta.protocols.jumping._protocols_jumping_.SameStrand:
tiny helper class that knows the relative fractions of secondary
structure L,H,E @detail so far these fractions can be computed
from a FragSet other input strategies are conceivable but not
implemented, yet: eg.
rosetta.core.fragment._core_fragment_.SecondaryStructure:
tiny helper class that knows the relative fractions of secondary
structure L,H,E @detail so far these fractions can be computed
from a FragSet other input strategies are conceivable but not
implemented, yet: eg.
rosetta.core.fragment._core_fragment_.SingleResidueFragData:
Base class for SRFD classes @detail Instances of SRFD classes
contain information on specific dofs in a single residue or a jump
connected to a residue The classes' apply method will now how to
implement the specified dofs in the give pose at the given residue
position TODO: change SRFD interface such that apply is called like
this apply( pose, inframe_pos (1..length), Frame const& )
jumpFrags can then ask the Frame for their upstream residue and
check that if they are at position 1 that they do nothgin...
rosetta.core.fragment._core_fragment_.IndependentBBTorsionSRFD:
A version of BBTorsionSRFD that considers each torsion
independently during is_applicable() and apply() calls when passed
a MoveMap (vs the all-torsions-must-be-moveable-or-nothing-is
behavior in the original BBTorsionSRFD).
rosetta.basic.resource_manager._basic_resource_manager_.ResourceOptionsFactory:
The %ResourceOptionsFactory class is responsible for maintaining
the map between the names of the ResourceOptions classes (strings)
and the ResourceOptionsCreator classes that are responsible for
instantiating the ResourceOption classes.
rosetta.core.chemical._core_chemical_.ChemicalManager:
a class managing different sets of atom_type_set and
residue_type_set make it as a singleton class so that atom_type_set
and residue_type_set are only input and initialized once.
rosetta.core.id._core_id_.TorsionID:
Torsion identifier class Consider a few examples to get a better
picture for how torsions are uniquely identified: @code #include
<core/id/types.hh> using core::id::BB; TorsionID(253, BB, 1)
// Phi backbone torsion of residue 253.
rosetta.basic._basic_.TracerManager:
Simple singleton class to hold the all_tracers_ array, which
otherwise suffers from funky double-construction problems when
declared as a static data member of Tracer.
rosetta.protocols.frag_picker._protocols_frag_picker_.VallChunkFilter:
a base class for a chunk filtering mechanism Chunk filtering is
used to screen chunks before any fragment is evaluated Therefore it
is the fastest way to excluded unwanted proteins @see
AllowPdbIdFilter and DenyPdbIdFilter for implementations
rosetta.utility._utility_.recent_history_queue:
A class for keeping track of a subset of elements in a set that are
pushed into a queue in a certain order, and which fall off the end
of the queue in ther order in which they arrive.
rosetta.utility._utility_.subset_mapping:
This class handles the bookeeping to map between a set of integer
ids in the "source" enumeration to a subset of those ids
-- the destination enumartion.
rosetta.numeric._numeric_.EulerAngles_Real:
Euler angles 3-D orientation representation @remarks The three
euler angles (in radians) that describing a rotation operation of a
Z axis rotation by the angle phi (position 1), followed by an X
axis rotation by the angle theta (position 3), followed by another
Z axis rotation by the angle psi (position 2).
rosetta.numeric._numeric_.EulerAngles_double:
Euler angles 3-D orientation representation @remarks The three
euler angles (in radians) that describing a rotation operation of a
Z axis rotation by the angle phi (position 1), followed by an X
axis rotation by the angle theta (position 3), followed by another
Z axis rotation by the angle psi (position 2).
rosetta.numeric._numeric_.EulerAngles_float:
Euler angles 3-D orientation representation @remarks The three
euler angles (in radians) that describing a rotation operation of a
Z axis rotation by the angle phi (position 1), followed by an X
axis rotation by the angle theta (position 3), followed by another
Z axis rotation by the angle psi (position 2).
int:
int(x=0) -> int or long int(x, base=10) -> int or long
rosetta.core.scoring.hbonds._core_scoring_hbonds_.HBAccChemType:
////////////////////////////////////////////////////////////////////////////
/// WARNING WARNING WARNING /// /// Changing the HBAccChemType or
HBDonChemType will change the /// sort order in
hbonds::hbtrie::HBAtom::operator<(...) and ///
hbonds::hbtrie::HBAtom::operator==(...).
rosetta.core.scoring.hbonds._core_scoring_hbonds_.HBondWeightType:
//////////////////////////////////////////////////////////////////////////////
//// WARNING WARNING WARNING //// //// if you modify the hbond
types please update the strings name //// in ScoreTypeManager.cc
//// //// WARNING WARNING WARNING
//////////////////////////////////////////////////////////////////////////////
rosetta.basic._basic_.ProfTag:
not intended for profiling inside tight loops
the clock() routine currently being used has fairly crappy
resolution and it will introduce some small overhead with the
function calls and the if-check even if not using -profile on
the command line
you can wrap it around large-ish chunks of code, like fullatom_energy
or rotamer_trials...
rosetta.core.scoring._core_scoring_.ScoreType:
//////////////////////////////////////////////////////////////////////////////
//// WARNING WARNING WARNING
////
//// if you add a new ScoreType please also add its string name in ScoreTypeManager.cc
////
//// WARNING WARNING WARNING
//////////////////////////////////////////////////////////////////////////////
Type for looking up cached energies
@remark I guess we could get rid of the fa_ prefix, except maybe for
fa_pair, to distinguish from std::pair and the centroid pair score...
rosetta.protocols.moves._protocols_moves_.StatsType:
////////////////////////////////////////////////////////////////////////////
A TrialMover applies a Mover and then accepts or rejects the move
according to a MonteCarlo object.
rosetta.protocols.jd2._protocols_jd2_.mpi_tags:
Tags used to tag messeges sent by MPI functions used to decide
whether a slave is requesting a new job id or flagging as job as
being a bad input