Rosetta  2020.37
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Typedefs | Functions | Variables
protocols::loophash Namespace Reference

Classes

class  BackboneDB
 
class  BackboneSegment
 
struct  BBData
 
struct  BBExtraData
 
class  EXCN_bbdb_Merge_Failed
 
class  EXCN_DB_IO_Failed
 
class  EXCN_Invalid_Hashmap
 
class  EXCN_No_Extra_Data_To_Write
 
class  EXCN_Wrong_DB_Format
 
class  FastGapMover
 Not implemented! Mover class for closing gaps. More...
 
struct  FilterBucket
 
struct  LeapIndex
 Store information about a particular Leap. More...
 
struct  LegacyLeapIndex
 
class  LocalInserter
 Manages the insertion of an arbitrary length of backbone in a local manner. More...
 
class  LocalInserter_SimpleMin
 Insert a backbone segment and use minimization with coordinate constraints to keep the insertion local. More...
 
class  LoopHashDiversifier
 Use LoopHash to generate low-resolution alternate conformations for the given pose. More...
 
class  LoopHashDiversifierCreator
 
class  LoopHashLibrary
 
class  LoopHashLibraryLoader
 LoopHashLibraryLoader constructs a LoopHashLibrary instance from data provided by the ResourceManager. More...
 
class  LoopHashLibraryLoaderCreator
 LoopHashLibraryLoaderCreator allows the ResourceLoaderFactory to create a LoopHashLibraryLoader instance. More...
 
class  LoopHashMap
 the loop hash map stores LeapIndexes and a hashmap to access those LeapIndexes quickly by their 6D coordinates. More...
 
class  LoopHashMoverWrapper
 Use LoopHash to sample new high-resolution conformations for the given pose. More...
 
class  LoopHashMoverWrapperCreator
 
class  LoopHashRelaxProtocol
 Not implemented! More...
 
class  LoopHashSampler
 Create candidate structures where some residues have been sampled by loophash. More...
 
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::shared_ptr
< FastGapMover
FastGapMoverOP
 
typedef
utility::pointer::shared_ptr
< FastGapMover const > 
FastGapMoverCOP
 
typedef
utility::pointer::shared_ptr
< LocalInserter
LocalInserterOP
 
typedef
utility::pointer::shared_ptr
< LocalInserter const > 
LocalInserterCOP
 
typedef
utility::pointer::shared_ptr
< LocalInserter_SimpleMin
LocalInserter_SimpleMinOP
 
typedef
utility::pointer::shared_ptr
< LocalInserter_SimpleMin
const > 
LocalInserter_SimpleMinCOP
 
typedef
utility::pointer::shared_ptr
< LoopHashLibrary
LoopHashLibraryOP
 
typedef
utility::pointer::shared_ptr
< LoopHashLibrary const > 
LoopHashLibraryCOP
 
typedef
utility::pointer::shared_ptr
< LoopHashLibraryLoader
LoopHashLibraryLoaderOP
 
typedef
utility::pointer::shared_ptr
< LoopHashLibraryLoader const > 
LoopHashLibraryLoaderCOP
 
typedef
utility::pointer::shared_ptr
< LoopHashLibraryOptions > 
LoopHashLibraryOptionsOP
 
typedef
utility::pointer::shared_ptr
< LoopHashLibraryOptions const > 
LoopHashLibraryOptionsCOP
 
typedef
utility::pointer::shared_ptr
< LoopHashRelaxProtocol
LoopHashRelaxProtocolOP
 
typedef
utility::pointer::shared_ptr
< LoopHashRelaxProtocol const > 
LoopHashRelaxProtocolCOP
 
typedef
utility::pointer::shared_ptr
< LoopHashSampler
LoopHashSamplerOP
 
typedef
utility::pointer::shared_ptr
< LoopHashSampler const > 
LoopHashSamplerCOP
 
typedef
utility::pointer::shared_ptr
< Mover_LoopHashRefine
Mover_LoopHashRefineOP
 
typedef
utility::pointer::shared_ptr
< Mover_LoopHashRefine const > 
Mover_LoopHashRefineCOP
 
typedef
utility::pointer::shared_ptr
< WorkUnit_LoopHash
WorkUnit_LoopHashOP
 
typedef
utility::pointer::shared_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)
 
int loophash_main ()
 
static basic::Tracer TR ("MPI.LHR")
 
static basic::Tracer TR ("MPI.LHR.Emperor")
 
static basic::Tracer TR ("MPI.LHR.Master")
 
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
typedef utility::pointer::shared_ptr< FastGapMover const > protocols::loophash::FastGapMoverCOP
typedef utility::pointer::shared_ptr< FastGapMover > protocols::loophash::FastGapMoverOP
typedef utility::pointer::shared_ptr< LocalInserter_SimpleMin const > protocols::loophash::LocalInserter_SimpleMinCOP
typedef utility::pointer::shared_ptr< LocalInserter const > protocols::loophash::LocalInserterCOP
typedef utility::pointer::shared_ptr< LocalInserter > protocols::loophash::LocalInserterOP
typedef utility::pointer::shared_ptr< LoopHashLibrary const > protocols::loophash::LoopHashLibraryCOP
typedef utility::pointer::shared_ptr< LoopHashLibraryLoader const > protocols::loophash::LoopHashLibraryLoaderCOP
typedef utility::pointer::shared_ptr< LoopHashLibrary > protocols::loophash::LoopHashLibraryOP
typedef utility::pointer::shared_ptr< LoopHashLibraryOptions const > protocols::loophash::LoopHashLibraryOptionsCOP
typedef utility::pointer::shared_ptr< LoopHashLibraryOptions > protocols::loophash::LoopHashLibraryOptionsOP
typedef utility::pointer::shared_ptr< LoopHashRelaxProtocol const > protocols::loophash::LoopHashRelaxProtocolCOP
typedef utility::pointer::shared_ptr< LoopHashSampler const > protocols::loophash::LoopHashSamplerCOP
typedef utility::pointer::shared_ptr< LoopHashSampler > protocols::loophash::LoopHashSamplerOP
typedef utility::pointer::shared_ptr< Mover_LoopHashRefine const > protocols::loophash::Mover_LoopHashRefineCOP
typedef utility::pointer::shared_ptr< Mover_LoopHashRefine > protocols::loophash::Mover_LoopHashRefineOP
typedef utility::pointer::shared_ptr< WorkUnit_LoopHash const > protocols::loophash::WorkUnit_LoopHashCOP
typedef utility::pointer::shared_ptr< WorkUnit_LoopHash > protocols::loophash::WorkUnit_LoopHashOP

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 
)
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 protocols::cluster::calibur::aa, core::chemical::aa_vrt, core::kinematics::FoldTree::add_edge(), core::kinematics::FoldTree::cutpoints(), core::pose::Pose::fold_tree(), core::chemical::ResidueTypeBase::is_polymer(), core::pose::Pose::jump(), protocols::make_rot_lib::PEPTIDE, core::pose::Pose::residue_type(), core::kinematics::FoldTree::root(), core::pose::Pose::size(), and protocols::moves::TR().

Referenced by protocols::abinitio::FragmentSampler::check_loops(), 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)
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.FastGapMover"  )
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 ( "protocols.loophash.LoopHashMoverWrapper"  )
static
static basic::Tracer protocols::loophash::TR ( "LoopHashMap"  )
static
static basic::Tracer protocols::loophash::TR ( "protocols.loophash.LoopHashDiversifier"  )
static
static basic::Tracer protocols::loophash::TR ( "LoopHashLibrary"  )
static

Variable Documentation

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