Rosetta 3.4
Classes | Typedefs | Functions | Variables
protocols::loophash Namespace Reference

Classes

struct  BBExtraData
struct  BBData
class  BackboneSegment
class  BackboneDB
class  EXCN_DB_IO_Failed
class  EXCN_Invalid_Hashmap
class  EXCN_No_Extra_Data_To_Write
class  EXCN_Wrong_DB_Format
class  EXCN_bbdb_Merge_Failed
class  FastGapMover
 Mover class for closing gaps. This Mover checks for any gaps using residue residue distances Then eats back at the chain surrounding it until loophash finds a fragment that fits in the space without changing the rest of pose too much. More...
class  LocalInserter
class  LocalInserter_SimpleMin
class  LoopHashLibrary
struct  LeapIndex
 The LeapIndex stores information about a particular Leap. It hold the oroiginal high precision rigid body transform and an Index to a Backbone Database (BackboneDB) that has the actual phi psi angles. THe storage of the precise RT takes a lot of space and may be deprecated at some point, since once it is hashed, it is rarely needed and can be recomputed if it is. Note that the length of the loop is not stored either, this is again done for saving memory, as huge lists of Leaps are typically created all with the same length. THe length is stored and handled by the owner of LeapIndex list. The LeapIndex does not store the actual backbone coordinates of the Leap. It merely contains an index (the BackboneIndex) which refers to a serial store of backbone triples (phi,psi, omega) which are stored somewhere else in a BackboneDB. THis is improtant to save memory storage since multiple Leaps cna share the same backbone triple and redundant storage would be hugely wasteful. More...
struct  LegacyLeapIndex
class  LoopHashMap
 the loop hash map stores LeapIndexes and a hashmap to access those LeapIndexes quickly by their 6D coordinates. More...
class  LoopHashMoverWrapper
class  LoopHashMoverWrapperCreator
class  LoopHashSampler
class  Mover_LoopHashRefine
class  MPI_LoopHashRefine
class  MPI_LoopHashRefine_Emperor
class  MPI_LoopHashRefine_Master
class  WorkUnit_LoopHash

Typedefs

typedef
boost::unordered_multimap
< boost::uint64_t, core::Size,
numeric::geometry::hashing::bin_index_hasher > 
BackboneIndexMap
typedef
numeric::geometry::BoundingBox
< core::Vector
BoundingBox
typedef
utility::pointer::owning_ptr
< FastGapMover
FastGapMoverOP
typedef
utility::pointer::owning_ptr
< FastGapMover const > 
FastGapMoverCOP
typedef
utility::pointer::owning_ptr
< LocalInserter
LocalInserterOP
typedef
utility::pointer::owning_ptr
< LocalInserter const > 
LocalInserterCOP
typedef
utility::pointer::owning_ptr
< LocalInserter_SimpleMin
LocalInserter_SimpleMinOP
typedef
utility::pointer::owning_ptr
< LocalInserter_SimpleMin
const > 
LocalInserter_SimpleMinCOP
typedef
utility::pointer::owning_ptr
< LoopHashInserter > 
LoopHashInserterOP
typedef
utility::pointer::owning_ptr
< LoopHashInserter const > 
LoopHashInserterCOP
typedef
utility::pointer::owning_ptr
< LoopHashLibrary
LoopHashLibraryOP
typedef
utility::pointer::owning_ptr
< LoopHashLibrary const > 
LoopHashLibraryCOP
typedef
utility::pointer::owning_ptr
< LoopHashSampler
LoopHashSamplerOP
typedef
utility::pointer::owning_ptr
< LoopHashSampler const > 
LoopHashSamplerCOP
typedef
utility::pointer::owning_ptr
< Mover_LoopHashRefine
Mover_LoopHashRefineOP
typedef
utility::pointer::owning_ptr
< Mover_LoopHashRefine const > 
Mover_LoopHashRefineCOP
typedef
utility::pointer::owning_ptr
< WorkUnit_LoopHash
WorkUnit_LoopHashOP
typedef
utility::pointer::owning_ptr
< WorkUnit_LoopHash const > 
WorkUnit_LoopHashCOP

Functions

static basic::Tracer TR ("BackboneDB")
short RealAngleToShort (core::Real angle)
core::Real ShortToRealAngle (short angle)
core::Real get_rmsd (const BackboneSegment &bs1, const BackboneSegment &bs2)
template<class T >
sqr (T a)
static basic::Tracer TR ("protocols.loophash.FastGapMover")
static basic::Tracer TR ("LocalInserter")
static basic::Tracer TR ("LoopHashLibrary")
static basic::Tracer TR ("LoopHashMap")
bool get_rt_over_leap (const core::pose::Pose &orig_pose, core::Size ir, core::Size jr, numeric::geometry::hashing::Real6 &rt_6)
 This takes a pose and two residue positions and determines the rigid body transform of the Leap described by those two residues. Returns true is successful or false if something went haywire and one should just ignore this loop (this can happen at the ends)
bool get_rt_over_leap_fast (core::pose::Pose &pose, core::Size ir, core::Size jr, numeric::geometry::hashing::Real6 &rt_6)
 This takes a pose and two residue positions and determines the rigid body transform of the Leap described by those two residues THe difference between this and the get_rt_over_leap function is that this version doesnt make a copy of the pose which makes it faster. However this means that the pose passed cannot be a const pose, even though the function restores the fold tree afterwards..
static basic::Tracer TR ("protocols.loophash.LoopHashMoverWrapper")
static basic::Tracer TR ("LocalHashSampler")
bool cmp (core::pose::Pose a, core::pose::Pose b)
int loophash_main ()
static basic::Tracer TR ("MPI.LHR")
static
numeric::random::RandomGenerator 
RG (9788321)
static basic::Tracer TR ("MPI.LHR.Emperor")
static
numeric::random::RandomGenerator 
RG (1248321)
static basic::Tracer TR ("MPI.LHR.Master")
static
numeric::random::RandomGenerator 
RG (3893251)
static basic::Tracer TR ("WorkUnit_LoopHash")

Variables

const core::Real MAXIMAL_FLOAT = 100000000.0
const int HASH_POSITION_GRID_BASE = 5

Typedef Documentation

typedef boost::unordered_multimap< boost::uint64_t, core::Size , numeric::geometry::hashing::bin_index_hasher > protocols::loophash::BackboneIndexMap
typedef numeric::geometry::BoundingBox< core::Vector > protocols::loophash::BoundingBox

Function Documentation

bool protocols::loophash::cmp ( core::pose::Pose  a,
core::pose::Pose  b 
)
core::Real protocols::loophash::get_rmsd ( const BackboneSegment &  bs1,
const BackboneSegment &  bs2 
)
bool protocols::loophash::get_rt_over_leap ( const core::pose::Pose orig_pose,
core::Size  ir,
core::Size  jr,
numeric::geometry::hashing::Real6 &  rt_6 
)

This takes a pose and two residue positions and determines the rigid body transform of the Leap described by those two residues. Returns true is successful or false if something went haywire and one should just ignore this loop (this can happen at the ends)

References core::chemical::aa_vrt, make_table_of_pilot_apps::f, core::pose::Pose::fold_tree(), core::pose::Pose::residue_type(), core::kinematics::FoldTree::root(), core::pose::Pose::total_residue(), and protocols::moves::TR().

Referenced by protocols::loophash::LoopHashLibrary::apply_random(), protocols::loophash::LoopHashSampler::build_structures(), protocols::loophash::LoopHashSampler::close_gaps(), protocols::loophash::LoopHashLibrary::get_all(), and protocols::loophash::LoopHashLibrary::test_loop_sample().

bool protocols::loophash::get_rt_over_leap_fast ( core::pose::Pose pose,
core::Size  ir,
core::Size  jr,
numeric::geometry::hashing::Real6 &  rt_6 
)

This takes a pose and two residue positions and determines the rigid body transform of the Leap described by those two residues THe difference between this and the get_rt_over_leap function is that this version doesnt make a copy of the pose which makes it faster. However this means that the pose passed cannot be a const pose, even though the function restores the fold tree afterwards..

This takes a pose and two residue positions and determines the rigid body transform of the Leap described by those two residues Returns true is successful or false if something went haywire and one should just ignore this loop (this can happen at the ends) THe difference between this and the get_rt_over_leap function is that this version doesnt make a copy of the pose which makes it faster. However this means that the pose passed cannot be a const pose, even though the function restores the fold tree afterwards..

References core::chemical::aa_vrt, core::kinematics::FoldTree::cutpoints(), make_table_of_pilot_apps::f, core::pose::Pose::fold_tree(), core::chemical::ResidueType::is_polymer(), core::pose::Pose::jump(), core::pose::Pose::residue_type(), core::kinematics::FoldTree::root(), core::pose::Pose::total_residue(), and protocols::moves::TR().

Referenced by protocols::loophash::LoopHashLibrary::extract_data_from_pose().

int protocols::loophash::loophash_main ( )
short protocols::loophash::RealAngleToShort ( core::Real  angle)
static numeric::random::RandomGenerator protocols::loophash::RG ( 9788321  ) [static]
static numeric::random::RandomGenerator protocols::loophash::RG ( 1248321  ) [static]
static numeric::random::RandomGenerator protocols::loophash::RG ( 3893251  ) [static]
core::Real protocols::loophash::ShortToRealAngle ( short  angle)
template<class T >
T protocols::loophash::sqr ( a)
static basic::Tracer protocols::loophash::TR ( "protocols.loophash.LoopHashMoverWrapper"  ) [static]
static basic::Tracer protocols::loophash::TR ( "MPI.LHR"  ) [static]
static basic::Tracer protocols::loophash::TR ( "MPI.LHR.Master"  ) [static]
static basic::Tracer protocols::loophash::TR ( "MPI.LHR.Emperor"  ) [static]
static basic::Tracer protocols::loophash::TR ( "BackboneDB"  ) [static]
static basic::Tracer protocols::loophash::TR ( "LoopHashMap"  ) [static]
static basic::Tracer protocols::loophash::TR ( "protocols.loophash.FastGapMover"  ) [static]
static basic::Tracer protocols::loophash::TR ( "WorkUnit_LoopHash"  ) [static]
static basic::Tracer protocols::loophash::TR ( "LoopHashLibrary"  ) [static]
static basic::Tracer protocols::loophash::TR ( "LocalInserter"  ) [static]
static basic::Tracer protocols::loophash::TR ( "LocalHashSampler"  ) [static]

Variable Documentation

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines