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

static thread_local basic::Tracer	TR ("protocols.loophash.FastGapMover")

static thread_local basic::Tracer	TR ("LocalInserter")

static thread_local basic::Tracer	TR ("protocols.loophash.LoopHashDiversifier")

static thread_local basic::Tracer	TR ("LoopHashLibrary")

static thread_local 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 thread_local basic::Tracer	TR ("protocols.loophash.LoopHashMoverWrapper")

static thread_local basic::Tracer	TR ("LocalHashSampler")

bool	cmp (core::pose::Pose a, core::pose::Pose b)

utility::vector1< core::Real >	extract_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 thread_local basic::Tracer	TR ("MPI.LHR")

static thread_local basic::Tracer	TR ("MPI.LHR.Emperor")

static thread_local basic::Tracer	TR ("MPI.LHR.Master")

static thread_local 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_SimpleMin > protocols::loophash::LocalInserter_SimpleMinOP

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< LoopHashLibraryLoader > protocols::loophash::LoopHashLibraryLoaderOP

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< LoopHashRelaxProtocol > protocols::loophash::LoopHashRelaxProtocolOP

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
	)

References core::pose::getPoseExtraScore().

utility::vector1< core::Real > protocols::loophash::extract_sample_weights ( const core::pose::Pose & pose )

References core::pose::get_comment(), utility::split(), utility::string2float(), and core::pose::Pose::total_residue().

core::Real protocols::loophash::get_rmsd	(	const BackboneSegment &	bs1,
		const BackboneSegment &	bs2
	)

References protocols::loophash::BackboneSegment::omega(), protocols::loophash::BackboneSegment::phi(), and protocols::loophash::BackboneSegment::psi().

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

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(), protocols::make_rot_lib::PEPTIDE, numeric::constants::d::pi, 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(), 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
	)