Rosetta 3.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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  LoopHashDiversifier
 
class  LoopHashDiversifierCreator
 
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  LoopHashRelaxProtocol
 
struct  FilterBucket
 
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
< LoopHashRelaxProtocol
LoopHashRelaxProtocolOP
 
typedef
utility::pointer::owning_ptr
< LoopHashRelaxProtocol const > 
LoopHashRelaxProtocolCOP
 
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 ("protocols.loophash.LoopHashDiversifier")
 
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) More...
 
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.. More...
 
bool get_rt_over_leap_without_foldtree_bs (core::pose::Pose const &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. More...
 
static basic::Tracer TR ("protocols.loophash.LoopHashMoverWrapper")
 
static basic::Tracer TR ("LocalHashSampler")
 
bool cmp (core::pose::Pose a, core::pose::Pose b)
 
utility::vector1< core::Realextract_sample_weights (const core::pose::Pose &pose)
 
bool is_valid_backbone (const std::string &sequence, const core::Size &ir, const std::vector< core::Real > &phi, const std::vector< core::Real > &psi, bool &filter_pro, bool &filter_beta, bool &filter_gly)
 
static
numeric::random::RandomGenerator 
RG (9479)
 
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 
)
utility::vector1< core::Real > protocols::loophash::extract_sample_weights ( const core::pose::Pose pose)
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, core::kinematics::FoldTree::add_edge(), 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::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::add_edge(), core::kinematics::FoldTree::cutpoints(), 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(), protocols::forge::remodel::RemodelLoopMover::loophash_stage(), and protocols::loophash::LoopHashLibrary::test_saving_library().

bool protocols::loophash::get_rt_over_leap_without_foldtree_bs ( core::pose::Pose const &  pose,
core::Size  ir,
core::Size  jr,
numeric::geometry::hashing::Real6 &  rt_6 
)
bool protocols::loophash::is_valid_backbone ( const std::string &  sequence,
const core::Size ir,
const std::vector< core::Real > &  phi,
const std::vector< core::Real > &  psi,
bool filter_pro,
bool filter_beta,
bool filter_gly 
)
int protocols::loophash::loophash_main ( )
short protocols::loophash::RealAngleToShort ( core::Real  angle)
static numeric::random::RandomGenerator protocols::loophash::RG ( 1248321  )
static
static numeric::random::RandomGenerator protocols::loophash::RG ( 9788321  )
static
static numeric::random::RandomGenerator protocols::loophash::RG ( 3893251  )
static
static numeric::random::RandomGenerator protocols::loophash::RG ( 9479  )
static
core::Real protocols::loophash::ShortToRealAngle ( short  angle)
template<class T >
T protocols::loophash::sqr ( a)
static basic::Tracer protocols::loophash::TR ( "BackboneDB"  )
static
static basic::Tracer protocols::loophash::TR ( "LocalInserter"  )
static
static basic::Tracer protocols::loophash::TR ( "LocalHashSampler"  )
static
static basic::Tracer protocols::loophash::TR ( "WorkUnit_LoopHash"  )
static
static basic::Tracer protocols::loophash::TR ( "MPI.LHR.Emperor"  )
static
static basic::Tracer protocols::loophash::TR ( "protocols.loophash.LoopHashDiversifier"  )
static
static basic::Tracer protocols::loophash::TR ( "MPI.LHR"  )
static
static basic::Tracer protocols::loophash::TR ( "protocols.loophash.LoopHashMoverWrapper"  )
static
static basic::Tracer protocols::loophash::TR ( "protocols.loophash.FastGapMover"  )
static
static basic::Tracer protocols::loophash::TR ( "MPI.LHR.Master"  )
static
static basic::Tracer protocols::loophash::TR ( "LoopHashLibrary"  )
static
static basic::Tracer protocols::loophash::TR ( "LoopHashMap"  )
static

Variable Documentation

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