Merge pull request #2843 from RosettaCommons/everyday847/more_basepair_constraints
Enable base pair constraints -- set up from within code or from a 'constraints' file
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2568 from RosettaCommons/vmullig/minor_thread_fixes
Some minor thread-safety fixes.
A few minor things that I noticed, now fixed.
TODO:
- [x] Clean up basket of deplorables in ProQ_Energy.
- [x] Remove static var in PoseFromSFRBuilder. Should be local to class.
- [x] Fix issue in min_pack --> @aleaverfay .
- [x] Prohibit rotamer dumping if multi-threaded.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2842 from RosettaCommons/vmullig/shorten_voids_penalty_test
Halving the runtime of an integration test that occasionally times out.
The voids_penalty_energy_design integration test is a bit too long, and is just on the cusp of timing out on the test server. It results in random failures due to occasional timeouts. This PR shortens the integration test a bit.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2838 from RosettaCommons/basantab/fix_VLB_vector1_index0
A for loop was using index 0 in the Vector1 type abego_ variable in VLB
Vikram K. Mulligan 7 years The voids_penalty_energy_design integration test broke here, but it wasn't your fault, Benjamin. The test is just a bit too long -- it's right on the cusp of timing out, and sometimes stochastically times out. I'll shorten it.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2839 from RosettaCommons/vmullig/restore_multithreading
Restoring the multi-threading in simple_cycpep_predict, which was wiped out by a toxic commit.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2834 from RosettaCommons/aleaverfay/datamap_access_improvement
DataMap::get() and get_ptr() efficiency
The previous way data was retrieved from the DataMap was wildly inefficient.
First, it made a complete copy of the inner std::map<string,RefCountOP> map, instead of asking for a reference, and then, instead of using find() on that inner map, it searched through all of its entries in O(n) fashion. Why even have a map if you're going to search that way?
So now the inner map is retrieved by reference (thanks, Sergey, for pointing out this inefficiency) and then the inner map's find() function is used for O(ln(n)) search.
I was seeing a large number of trajectory changes due to these changes in a number of integration tests in another branch, so I am moving these changes into their own branch to merge by themselves. Stangely, these modifications on their own are not producing the trajectory changes I was seeing in another branch, so I'm kinda confused.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2811 from RosettaCommons/roccomoretti/fix_pose_rts_patching
Fix behavior of PoseResidueTypeSet w/r/t patching
Because of the way the base type generate_residue_type_write_locked() was implemented, the previous version of PoseResidueTypeSet actually re-patched types, such that the ResidueType object of, say, GLU:NtermProteinFull is a different object when pulled from PoseResidueTypeSet versus from the associated GlobalResidueTypeSet (they're functionally equivalent, they're just two different objects). To increase efficiency, this PR changes the PoseResidueTypeSet::generate_residue_type_write_locked() such that it will better defer patching to the associated GlobalResidueTypeSet.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2405 from RosettaCommons/everyday847/everyday847/chunk_jq_and_fixes
Implement a 'chunk JobQueen' for fragment assembly + fix some earlier RNA jd3 choices
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2824 from RosettaCommons/jadolfbr/glycosylation_pdbinfo
Keep input PDB numbering post-glycosylation
This PR finally fixes pose glycosylation to keep the input PDBInfo in tact and create sensible PDBInfo records for the new glycan.
The new glycan is now part of the Protein chain it was added to. The resulting Pose has the same numbering as before. This will streamline the use of the `SimpleGlycosylateMover` and glycosylation code for structure solutions, especially for EM density.
This is on by default, but can be turned off. All integration tests that glycosylate and output PDBs will change.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2755 from RosettaCommons/vmullig/voids_penalty
Add a guidance function to promote voids-free packing
Natural proteins have few to no voids in their cores. The packer, however, often produces solutions with voids. I think that there are often situations in which a better solution exists, albeit one that requires a little bit of minimization to relieve minor clashes (which is why the packer avoids these solutions). Our usual solution is to produce a _lot_ of designs and to filter based on holes, throwing away most of the designs due to buried voids. This, of course, is inefficient. To try to coax the packer towards better-packed solutions, I'm adding a design-centric score term to penalize deviation from solutions in which the total buried rotamer volume differs significantly from the total volume that one is trying to fill. I think I have a way to do this that moves most of the cost to a precomputation, so that the cost during the simulated annealing search is negligible, but I want to try this out to be sure.
Merge approved by TJ Brunette.
@asford
Tasks:
- [x] Add `VoidsPenaltyEnergy` (copy from `NetChargeEnergy`).
- [x] Register energy appropriately.
- [x] Write precomputation:
- [x] Class for voxel grid.
- [x] Set up voxel grid.
- [x] Identify buried voxels (using sidechain cones method).
- Note that this is a good task for a GPU... Hmm...
- ~~Figure out how to make this faster. (Can probably do a low-res pass first to figure out the relevant cones for each group of voxels).~~ --> Doesn't need to be faster. This isn't rate-limiting.
- [x] Set up rotamers. For each rotamer, compute volume lying in buried volume (by counting buried voxels that the rotamer overlaps).
- Also a good task for a GPU. Hmm...
- I'll do this in a SLIGHTLY imprecise way:
- For each atom in rotamer, ask whether the atom centre is in a buried voxel.
- If it is, add the atom to a list of buried atoms for the rotamer.
- Sum the volume of the buried atoms for the rotamer (4/3*Pi\*r^3 for each atom), then subtract the overlap integrals of every pair of atoms.
- Assumption: adding back the overlap triples isn't worth it because they contribute negligibly.
- Assumption2: if the atom centre is buried, the whole atom is probably buried, while if the atom centre is not buried, the whole atom is probably not buried (a good enough approximation for grids with large voxels).
- [x] Unit test for the rotamer setup.
- [x] Fix this unit test's failure.
- [x] Prune voxels that no rotamer touches, and calculate total buried packable volume.
- [x] Write computation performed during simulated annealing search:
- [x] For each step, impose a quadratically-ramping penalty based on the square of the difference
between the total volume and the sum of the current rotamer volumes.
- [x] Unit test: pack with this alone, and check that small volume deviations are achievable.
- [x] Make the values that I initially hard-coded in `VoidsPenaltyVoxelGrid::is_buried()` into ones that can be configured _via_ the options system (with proper options objects -- not global reads).
- [x] Add to `EnergyMethodOptions`, have the `VoidsPenaltyEnergy` read from an `EnergyMethodOptions` object, and configure the internal `VoidsPenaltyVoxelGrid` when it creates that object.
- [x] The number of cones in which a voxel must be found to be considered buried is still hard-coded (at "6"). This should also be added to `EnergyMethodOptions` and `ScoreFunctionLoader`.
- [x] Prune voxels of residues that are fixed during packing.
- [x] Disable during minimization -- too expensive.
- ~~Hmm. I'm still seeing calls during minimization. Track down and figure out how to disable.~~ --> These are calls to basic scoring peripheral to minimization in the `FastDesign` protocol. Maybe I'll add an option for disabling scoring outright except during packing.
- [x] Option for disabling scoring outright except during packing.
- ~~Might as well apply this to `aa_composition`, `hbnet`, and `netscore` terms, too. They don't need to be evaluated during minimization trajectories.~~ --> For a future pull request.
- [x] Figure out a good way to do this for once-off scoring.
- [x] Oh crap -- symmetry.
- [x] Make the system work with symmetry.
- [x] Unit tests for VoidsPenaltyEnergy with symmetry.
- [x] Symmetric integration test.
- [x] Unit tests.
- [x] Integration test.
- [x] Shorten integration tests a bit.
- [x] Beauty.
- [x] Documentation.
- [x] Benchmark: calculate buried voids after design with and without this term, for many sampled backbones.
- [x] Figure out largest voxel size that still produces good behaviour, and make this default.
- Seems like 0.5 A is pretty good. This produces a 60% slowdown during packing of a 100-residue pose, but still creates much better-packed solutions.
- Eliminating unnecessary `voids_penalty` evaluation during scoring steps in between packer steps in FastDesign, the slowdown drops to a 23% slowdown when designing the core and boundary of a 100-residue pose.
- [x] Figure out time cost for this term.
Also:
- [x] Update function signature in ResidueArrayAnnealableEnergy for setting up for packing. (Allow rotamer sets to be passed to energy method during setup.)
- [x] Update ResidueArrayAnnealableEnergy derived classes to use the C++11 `override` keyword correctly.
notify author
notify list [rosetta-logs@googlegroups.com]