Merge pull request #1872 from RosettaCommons/jadolfbr/dump_pdb_residue
Jadolfbr/dump pdb residue
Enables the dump_pdb_residue function of pdb_writer to work in PyRosetta. Forgot this PR was still open.
https://www.rosettacommons.org/node/9826
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2370 from RosettaCommons/jadolfbr/fix_glycan_data
Update Glycan Conformer data
This updates the glycan conformer data using higher-level filtering using the glycosciences pdbcare 'bit' values. This edges more on the cautious side in order to filter torsions that may or may not be correct.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2373 from RosettaCommons/vmullig/fix_genkic_sugars
Fix the genkic_sugars integration test in debug mode
Some debug_assert is tripping up the test. I need to figure out what's wrong and fix it.
Update: the logic for detecting noncanonical connections assumed that the only time that a polymer residue would lack a lower connection would be if it were a lower terminus type. This assumption is not true for all glycans. The simple fix is to check for a lower connection instead of checking for the lower terminus type.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2334 from RosettaCommons/vmullig/fix_genkic_sugars
Fix bug in GenKIC that was preventing its use for sugar chains
I was rebuilding connection-dependent atoms foolishly in GenKIC, resulting in an inadvertent distortion to the C2 atoms in sugars. I'm pretty sure that the place where I was doing this is a place where this doesn't need to be done at all. This might cause very minor integration test changes to anything that uses GenKIC.
A number of GenKIC-related integration test changes are expected.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2360 from RosettaCommons/aleaverfay/threadsafe_rts
This PR lays down some thread safety for an eventual JD3 MultiThreadedJobDistributor. Here, I am working to ensure thread safety for the just-in-time ResidueType loading system as implemented by @rhiju and maintained by @roccomoretti and @everyday847. The idea is this:
The ResidueTypeSet (RTS) will create read locks on its ResidueTypeSetCache (RTSC) before each time it is read from. If it determines that an operation it requries will modify the RTSC, then it releases the read lock and then tries to obtain a write lock.
(Briefly, the "ReadWriteMutex" allows several threads to say "I'm reading" by incrementing a mutex-controlled counter when they start reading, and decrementing that counter when they are done. If a thread decides it needs write permission, then it prevents any more readers from coming along and gaining read permission, while waiting for all the existing threads to complete their work. Once they've completed, then the write lock is granted and the thread may write. One complexity of working with read/write locks is that a thread may deadlock itself if it does something such as obtain a read lock, and then later try to obtain a write lock. Since the read lock is never released, the write lock will never be obtained and the thread will sit there and do nothing. Indeed, if the locks are obtained in the opposite order (first the write lock, then the read lock), the system will also deadlock. Systems involving read/write locks need to build into themselves rules about which functions are off limits at which times.)
The RTS's public interface will handle all the locking required -- the complexity of who is allowed to do what is managed internally by the RTS and its derived classes. The RTS base class provides several template methods that derived classes will supply implementations for (i.e. the GlobalResidueTypeSet and the PoseResidueTypeSet) where these methods will come with lock-based promises and requirements (e.g. generate_residue_type_write_locked is only invoked by the base class after a write lock has been obtained therefor all interactions inside this function with the RTSC are safe -- but the function should not call any of the methods of the RTS that themselves try and obtain read or write locks).
This system is significantly less brittle than the one I had begun working on, and which @roccomoretti helped talk me out of, where the ResidueTypeFinder would be obtaining read and write locks on the RTSC -- that system might have slight performance advantages, however, as it allows the thread to obtain a single read lock or a single write lock and then to complete all of its operations. The PR where I began working on that, PR #2353, has been shelved. Perhaps if this current system proves too slow, we can reconsider its approach
Sergey Lyskov 7 years Andrew, please ignore Linux PyRosetta unit test failure, - it is due to problem with routing on Hojo-1/Takeshi. (I am already looking this up)
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2361 from RosettaCommons/roccomoretti/mpi_cycpep_logfix
Attempt to fix stochastic interleaving of logs in mpi_simple_cycpep_predict
We're getting some spurious logfile changes on the test server due to interleaving logs. Use -mpi_tracer_to_file to address this.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2362 from RosettaCommons/roccomoretti/rosettacm_template_length
Fix bad error message with RosettaCM length mismatch.
If you have a mismatch between the length of the template and the length of the input in RosettaCM
(Specifically if your templates are accidentally longer than your input.)
You can get really non-informative errors. (e.g. memory corruption due to writing off the end of a vector in release mode.)
Check for this condition, and pop up an intelligible error message if it occurs.
notify author
notify list [rosetta-logs@googlegroups.com]
Merge pull request #2356 from RosettaCommons/roccomoretti/gcc7.1_fixes
Fixes for GCC 7.1
There's a number of issues (both warning-as-errors as well as actual compiler-quits errors) that pop up when compiling Rosetta with GCC 7.1. This PR should fix those.
The main changes are in places where switch/case statements can "fall through" (breaks/returns added) and a change in how we handle multi-level templated class resolution in SingelResidueDunbrackLibrary (as GCC 7.1 has issues with the way we were doing it before.)
Surprisingly, no test changes are expected, aside from the ones that are failing in master.
notify author
notify list [rosetta-logs@googlegroups.com]
Switching all simple_cycpep_predict integration tests to use ref2015 (more commonly known as "Scorey McScoreface") instead of talaris2014. All future simple_cycpep_predict development will be for the new Park/DiMaio energy functions.
notify author
notify list [rosetta-logs@googlegroups.com]