Rosetta Protocols  2014.35
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
 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...
 
struct  FilterBucket
 
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  LocalInserter
 
class  LocalInserter_SimpleMin
 
class  LoopHashDiversifier
 
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  LoopHashLibraryOptions
 LoopHashLibraryOptions encapsulates the options associated with LoopHashLibrary resources. More...
 
class  LoopHashLibraryOptionsCreator
 LoopHashLibraryOptionsCreator allows the ResourceLoaderFactory to create a LoopHashLibraryOptions 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
 
class  LoopHashMoverWrapperCreator
 
class  LoopHashRelaxProtocol
 
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
< LoopHashLibrary
LoopHashLibraryOP
 
typedef
utility::pointer::owning_ptr
< LoopHashLibrary const > 
LoopHashLibraryCOP
 
typedef
utility::pointer::owning_ptr
< LoopHashLibraryLoader
LoopHashLibraryLoaderOP
 
typedef
utility::pointer::owning_ptr
< LoopHashLibraryLoader const > 
LoopHashLibraryLoaderCOP
 
typedef
utility::pointer::owning_ptr
< LoopHashLibraryOptions
LoopHashLibraryOptionsOP
 
typedef
utility::pointer::owning_ptr
< LoopHashLibraryOptions const > 
LoopHashLibraryOptionsCOP
 
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

short RealAngleToShort (core::Real angle)
 
core::Real ShortToRealAngle (short angle)
 
core::Real get_rmsd (const BackboneSegment &bs1, const BackboneSegment &bs2)
 
template<class T >
T sqr (T a)
 
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...
 
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 ()
 

Variables

static basic::Tracer TR ("BackboneDB")
 
const core::Real MAXIMAL_FLOAT = 100000000.0
 
const int HASH_POSITION_GRID_BASE = 5
 
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")
 
static basic::Tracer TR ("protocols.loophash.LoopHashMoverWrapper")
 
static basic::Tracer TR ("LocalHashSampler")
 
static
numeric::random::RandomGenerator 
RG (9479)
 
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")
 

Typedef Documentation

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::pose::Pose::fold_tree(), nres, protocols::make_rot_lib::PEPTIDE, numeric::constants::d::pi, core::pose::Pose::residue_type(), core::kinematics::FoldTree::root(), 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(), nres, protocols::make_rot_lib::PEPTIDE, numeric::constants::d::pi, core::pose::Pose::residue_type(), core::kinematics::FoldTree::root(), core::kinematics::Jump::rt(), core::pose::Pose::total_residue(), 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 
)

This takes a pose and two residue positions and determines the rigid body transform of the Leap described by those two residues.

References core::conformation::Residue::atom_index(), core::pose::Pose::conformation(), core::conformation::Conformation::get_stub_transform(), core::conformation::Residue::is_protein(), numeric::constants::d::pi, and core::pose::Pose::residue().

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 ( T  a)

Variable Documentation

const int protocols::loophash::HASH_POSITION_GRID_BASE = 5
const core::Real protocols::loophash::MAXIMAL_FLOAT = 100000000.0
numeric::random::RandomGenerator protocols::loophash::RG(1248321)
static
numeric::random::RandomGenerator protocols::loophash::RG(9788321)
static
numeric::random::RandomGenerator protocols::loophash::RG(3893251)
static
numeric::random::RandomGenerator protocols::loophash::RG(9479)
static
basic::Tracer protocols::loophash::TR("BackboneDB")
static

Referenced by protocols::loophash::LoopHashMoverWrapper::apply(), protocols::loophash::FastGapMover::apply(), protocols::loophash::LoopHashDiversifier::apply(), protocols::loophash::LoopHashLibrary::apply(), protocols::loophash::LoopHashLibrary::apply_random(), protocols::loophash::LoopHashSampler::build_structures(), protocols::loophash::LoopHashLibrary::create_db(), protocols::loophash::LoopHashLibrary::delete_db(), protocols::loophash::LoopHashLibrary::extract_data_from_pose(), protocols::loophash::LoopHashMoverWrapper::get_additional_output(), protocols::loophash::LoopHashLibrary::get_all(), protocols::loophash::LoopHashLibrary::graft_loop(), protocols::loophash::LoopHashLibrary::load_db(), protocols::loophash::LoopHashLibrary::load_mergeddb(), protocols::loophash::LoopHashMap::lookup(), protocols::loophash::LoopHashRelaxProtocol::manual_call(), protocols::loophash::LoopHashLibrary::mem_foot_print(), protocols::loophash::LoopHashMap::mem_foot_print(), protocols::loophash::LoopHashLibrary::merge(), protocols::loophash::LoopHashMoverWrapper::parse_my_tag(), protocols::loophash::LoopHashMap::read_db(), protocols::loophash::LoopHashMap::read_legacydb(), protocols::loophash::WorkUnit_LoopHash::run(), protocols::loophash::LoopHashLibrary::save_db(), protocols::loophash::WorkUnit_LoopHash::set_defaults(), protocols::loophash::LoopHashMap::setup(), protocols::loophash::LoopHashLibrary::setup_hash_maps(), protocols::loophash::LoopHashLibrary::test_loop_sample(), and protocols::loophash::LoopHashLibrary::test_saving_library().

basic::Tracer protocols::loophash::TR("LocalInserter")
static
basic::Tracer protocols::loophash::TR("LocalHashSampler")
static
basic::Tracer protocols::loophash::TR("WorkUnit_LoopHash")
static
basic::Tracer protocols::loophash::TR("MPI.LHR.Emperor")
static
basic::Tracer protocols::loophash::TR("protocols.loophash.LoopHashDiversifier")
static
basic::Tracer protocols::loophash::TR("protocols.loophash.LoopHashMoverWrapper")
static
basic::Tracer protocols::loophash::TR("MPI.LHR")
static
basic::Tracer protocols::loophash::TR("LoopHashLibrary")
static
basic::Tracer protocols::loophash::TR("MPI.LHR.Master")
static
basic::Tracer protocols::loophash::TR("protocols.loophash.FastGapMover")
static
basic::Tracer protocols::loophash::TR("LoopHashMap")
static