commit 3d995b15922374726493453159734beedd7e28be
Merge: 76be7e2 947a6d3
Date:   Wed Nov 20 17:52:20 2019 -0600

    Merge pull request #4377 from RosettaCommons/roccomoretti/fix_master_tests
    
    Fix clang tidy tests

commit 76be7e2f7be20ae41b8495c08961ee13a9ae0fc5
Merge: 3635117 43630b6
Date:   Wed Nov 20 23:56:56 2019 +0100

    Merge pull request #4376 from RosettaCommons/vorobieva/bugfix_remodel
    
    Bug fix in remodel disulfide builder

commit 36351172a006c6919ce76344da689779564b25aa
Merge: a7a1857 e5a6fdb
Date:   Wed Nov 20 13:30:38 2019 -0800

    Merge pull request #4359 from RosettaCommons/bcov/ContactMS
    
    Adding Contact Molecular Surface - a higher res SASA filter

commit a7a1857d5dab7ca3311a1d6699cdd63e864456d6
Merge: 5ff1224 115e498
Date:   Wed Nov 20 08:21:23 2019 -0800

    Merge pull request #4373 from RosettaCommons/jadolfbr/fix_symm_glycan_branches
    
    The function `extract_asymmetric_unit` for symmetry previously would crash for any glycan branch residues.  This PR special-cases branched carbohydrates and the protein-glycan branched connection.   Thanks to @JWLabonte and @fdimaio with their guidance on this.

commit 5ff1224c6ab79670be1c5da005a4161d807590cb
Merge: 42d3916 e86c4e6
Date:   Tue Nov 19 20:20:23 2019 -0500

    Merge pull request #4375 from RosettaCommons/vmullig/python_version_error
    
    Fixing integration tests so that they can run under Python 2

commit 42d39168225fbcdab8de418a71b093aaacb66680
Merge: 51b3219 4040d65
Date:   Fri Nov 15 18:59:29 2019 -0500

    Merge pull request #4369 from RosettaCommons/vmullig/fix_bad_unit_test
    
    Fix a unit test that was invalidating the output of its own sub-tests.
    
    The FA_ElecEnergy unit test suite's sub-tests were producing different results depending on whether they were run independently or as a suite. This was because the setup function called core_init(), while the first sub-test called core_init_with_additional_options( "-restore_pre_talaris_2013_behavior" ). Effectively, this meant that the sub-tests of the current defaults (which came later in the suite) were being performed against the -restore_pre_talaris_2013_behavior flag when the whole suite was run.
    
    I'm correcting this by splitting the suite into two unit test suites with two different core_init() calls in the setup function. I'm also updating the expected values in the sub-tests that assumed that they were testing the current default scorefunction instead of the pre-Talaris 2013 scorefunction.

commit 51b32192ecda3912475f19c913041c08396e9707
Merge: 8e7ca8e f151cbb
Date:   Fri Nov 15 15:29:39 2019 -0500

    Merge pull request #4017 from RosettaCommons/aleaverfay/matcher_bugfix_Jun2019
    
    Aleaverfay/matcher bugfix jun2019
    
    Belatedly fixing two bugs in the matcher brought to my attention by Indrek Kalvet.
    
    1) When using ligand conformers, the "relevant atoms" (not the clearest of designations, tbh) needs to include not only the atoms that define the protein/ligand contact, but also the atoms that define the ligand's orientation -- the "orientation atoms" (oats). When these were not included in the list of relevant atoms by the MatcherTask, then two ligand conformers with very different locations for the protein-contacting atoms could be treated as equivalent. Once equivalent, then only the location of the oats is used to decide if the two conformers represent a match. This led to some pretty outrageous "matches" where the active site residues were ~8 A away from the Zn they were meant to be 2 A from.
    
    2) When using the -dynamic_grid_refinement flag, it turned out that the process of estimating how many matches would be formed for a certain grid spacing was wicked slow. As a result, it was not really a time savings.
    
    All of Indrek's test cases now look good.

commit 8e7ca8e4fac61a701b8110c307aedbdd080064ed
Merge: 7db8c95 293b22e
Date:   Thu Nov 14 15:43:55 2019 -0700

    Merge pull request #4365 from RosettaCommons/sergey/binder
    
    Binder update to fix PyRosetta build on GCC-7/8/9

commit 7db8c952be8d4cdf93b857968e3b2cbe3476a4ab
Merge: f55eb0d 2724a98
Date:   Thu Nov 14 15:51:40 2019 -0600

    Merge pull request #4303 from RosettaCommons/roccomoretti/drug_design_background
    
    Grab-bag of changes from my drug design branch.
    
    This is a selection of changes from #1036 which touch existing code (Versus adding new classes/etc.) The changes all relate to things done with drug-design, but aren't dependent on the new stuff therein. (I apologize for the grab-bag nature of the changes. I didn't necessarily want to split things out further.)
    
    A short summary of major changes:
    
    *    Permit the MonteCarlo object to manage a pose, but use a score which isn't the pose's total score.
    *    Change logic in Residue::orient_onto_residue() to better handle orienting non-related types.
    *    Don't assume the root atom is atom 1 in core::pack::scmin::ResidueAtomTreeCollection
    *    Better diagnostics for CompoundFilter
    *    For ligand docking FinalMinimizer, add option to remove the constraints which the mover adds
    *    For ligand docking FinalMinimizer, fix nonsensical backbone-minimization-without-chainbreak-term
    *    For ligand docking HighResDocker, remove the dihedral restraints added (just like we remove the ligand tethers)
    *    Update automatic neighbor atom finding for MutableResidueType change
    *    Additional formatting options in SDF residue type input/output (still not ready for prime-time)
    *    Various convenience functions added.

commit f55eb0d95436b5ad8da34af1611d31ca73a79c74
Merge: e1e6145 4389e17
Date:   Wed Nov 13 23:36:10 2019 -0500

    Merge pull request #4361 from RosettaCommons/vmullig/clang_analysis_issues_again
    
    Fixing a "not read" error flagged by clang analysis.  I didn't hear back from @bioragul; will assume that this is fine.

commit e1e61459e6ead5a43804d6e96e4ac8ff9a6bd404
Merge: a984b21 a3e6a37
Date:   Tue Nov 12 18:13:52 2019 -0500

    Merge pull request #4355 from RosettaCommons/vmullig/simplify_threadmanager_api
    
    Reduce mutex contention a bit by reducing reliance on std::shared_ptr in RosettaThreadManager classes.
    
    I was being overcautious with my ownership model, and unnecessarily using vectors of owning pointers of functions.  This results in unnecessary locking of mutexes internal to `std::shared_ptr`, which can slow things down.  Worse, I was _copying_ the owning pointers around, which results in new locking every time the reference count is incremented or decremented.  (Even in the single-threaded build, unnecessarily passing around smart pointers is likely slowing things down a bit, since reference counts have to be incremented and decremented.)
    
    The vector object owns its contents and controls their destruction, so a vector of objects controlled by owning pointers is really unnecessary.  This pull request refactors a bit so that the `RosettaThreadManager` now accepts a vector of function objects instead of a vector of owning pointers to function objects.
    
    TODO:
    - [x] Also switch the RosettaThreadAssignmentInfo object to be a stack-allocated object passed by reference, rather than a heap-allocated object passed by owning pointer.
    - [x] Check profile tests.  Is there a performance benefit with packing in the single-threaded builds?  (See the core_pack_pdig_current_default_sfxn  performance test, which did show a slight drop in single-threaded execution when we switched to building a work vector and evaluating it). --> No big change.  Maybe a small improvement.
    - [x] Does this improve performance scaling for multi-threaded interaction graph calculation? --> Not really.
    - [x] Does this rescue the scoring performance in the single-threaded build in PR #4342? --> No.  Note, though, that the only slowdowns are with very fast-to-compute terms (_e.g._ chainbreak) or with an empty scorefunction.  If there's any work to be done at all, the slowdown is negligible.
    - [x] Does this improve performance scaling for multi-threaded scoring in PR #4342? --> Not really.

commit a984b21f93b91dedebc8a45440370bfa3d5877f5
Merge: 87f9cd7 ec6b454
Date:   Mon Nov 11 17:26:33 2019 -0500

    Merge pull request #4354 from RosettaCommons/aleaverfay/forward_kwargs_to_maybe_init
    
    Forward kwargs to maybe_init in pyrosertta distributed
    
    In pyrosetta::distributed initialization, pass the keyword arguments through
    to the maybe_init function.

commit 87f9cd71cc056b1bf8d69c13d76e4047fad14b6b
Merge: 8ead6c9 37b445a
Date:   Mon Nov 11 14:07:35 2019 -0500

    Merge pull request #4352 from RosettaCommons/vmullig/reduce_boost_dependency
    
    Reduce dependencies on Boost by switching to STL functions where feasible.
    
    Certain functions that were only defined in the Boost libraries are now part of the C++11 STL.  These include `std::bind`, `std::function`, `std::cref`, and `std::ref`.  This pull request aims to replace instances of `boost::bind`, `boost::function`, `boost::cref`, and `boost::ref` with their C++11 STL equivalents.

commit 8ead6c9e84dc936f70f9a92e2ea8894cfea78ca6
Merge: 7cd178f 5f25356
Date:   Mon Nov 11 13:38:55 2019 -0500

    Merge pull request #4329 from RosettaCommons/bioragul/TCRmodel-updates
    
    TCRmodel bug fixes & minor updates

commit 7cd178fe05f3b176a6f71a892b86c2736f4b5052
Merge: cbb227a 57134ba
Date:   Sun Nov 10 03:53:03 2019 -0500

    Merge pull request #4353 from RosettaCommons/JackMaguire/fix_INCLUDED_core_scoring_util_methods_DumpTrajectoryEnergy_hh
    
    Fixing #ifdef and duplication
    
    #3575 copied a file but didn't update the ifdef include guards. The duplicate_header_guards test failed but was ignored because it blended in with a lot of other failed integration tests (presumably expected failures).
    
    This PR fixes the #ifdef duplication but there might be a bigger problem here. Was src/core/energy_methods/DumpTrajectoryEnergy.hh even supposed to make it into master? Its namespaces are incorrect and it's a perfect duplicate of src/core/scoring/util_methods/DumpTrajectoryEnergy.hh
    
    Tagging @vmullig because it was his PR, and @bcov77 because github credits this file to him.

commit cbb227abd9c8ea718e853f116d68c3283a603297
Merge: 868bf3f ccd2a30
Date:   Fri Nov 8 14:48:23 2019 -0500

    Merge pull request #4262 from RosettaCommons/JackMaguire/StrongTypeAliases
    
    Strong Sizes in JD3
    
    `core::Size` is used frequently in JD3 (and Rosetta as a whole) to represent values that are conceptually different types but are all best represented with a simple `int`. Nobody should need to reinvent the `int` wheel every time we need a new integral type. `core::Size` is technically fine for all of these types but its ubiquitousness can lead to logic errors. The goal of this PR is to introduce distinct types for some common integral concepts in JD3. This will hopefully prevent bugs in JD3's already hard-to-understand framework.
    
    Here is a good example of this feature being added.
    
    Existing code:
    ```c++
    StandardInnerLarvalJobOP create_inner_larval_job(
      core::Size nstruct,
      core::Size job_node,
      core::Size preliminary_job_node
    ) const;
    
    InnerLarvalJobOP
    create_and_init_inner_larval_job_from_preliminary(
      core::Size nstruct,
      core::Size prelim_job_node,
      core::Size job_node
    ) const;
    ```
    
    These are two functions that JobQueen writers might replace with one another as drop-in replacements. If they do that, the compiler will not warn them that they need to _switch the 2nd and 3rd arguments_ because both arguments are core::Sizes. This logic error might not even be caught at runtime because `prelim_job_node` and `job_node` are often the same value for some JobQueens. The logic error might take months to reveal itself (like it did for MultistageRosettaScripts in #4238 ).
    
    New code:
    ```c++
    StandardInnerLarvalJobOP create_inner_larval_job(
      core::Size nstruct,
      JobDagID job_node,
      PrelimJobNodeID preliminary_job_node
    ) const;
    
    InnerLarvalJobOP
    create_and_init_inner_larval_job_from_preliminary(
      core::Size nstruct,
      PrelimJobNodeID prelim_job_node,
      JobDagID job_node
    ) const;
    ```
    
    This new code requires minimal boilerplate (thanks to Rocco's suggestions in #4237 ) and would immediately alert developers _at compile time_ when they are using values incorrectly. Performance hits will not be a concern because the compiler completely optimizes this feature away, even in debug mode (see godbolt links in #4237 ).

commit 868bf3f9db0e20a06d6f338cb810615e0d792320
Merge: 93f10bc 0060495
Date:   Fri Nov 8 13:01:12 2019 -0500

    Merge pull request #4345 from RosettaCommons/vmullig/make_FASTER_ig_threadsafe
    
    Add unit tests confirming that the FASTER interaction graph is threadsafe, and update test to use ref2015 instead of pre_talaris_2013_standard
    
    The FASTER interaction graph unit test fails stochastically in the multi-threaded build. This is likely due to a thread safety issue. This PR attempts to fix the issue.
    
    EDIT: The FASTER ig is, as far as I can tell, totally threadsafe. (This PR does add a pretty stringent test for this, computing the graph 100 times in threads and comparing each result to the graph computed in a single thread.) The score12 scorefunction, however, is not. I get concurrency issues ONLY when using score12, and these vanish with ref2015 (which is fully threadsafe). For now, I'm switching the FASTER ig unit test to use ref2015 instead of score12, though at some point I'll track down the concurrency issues in score12.

commit 93f10bc3df39bbe5fe2aae94748c0c62fab3c5e1
Merge: b470a6a 8cc5582
Date:   Thu Nov 7 18:14:42 2019 -0500

    Merge pull request #4350 from RosettaCommons/vmullig/fix_gcc_9_2_build
    
    Fixing gcc 9.2.0 compilation.
    
    A minor issue was introduced with the recent clang tidy clean-up. This PR replaces an explicitly-defined but trivial assignment operator with a default assignment operator to resolve the warning-as-error and to repair the build.
    
    @roccomoretti

commit b470a6a0d47e41477ee663f464503b97c7e95702
Merge: 0d7cf32 d6da552
Date:   Thu Nov 7 13:29:04 2019 -0600

    Merge pull request #4289 from RosettaCommons/jadolfbr/den_map_fix
    
    Add setters and getters for LoadDensityMapMover for use in PyRosetta.

commit 0d7cf3210320e9e31800f39f5e3264981d526f88
Merge: fa7471d 8227c6a
Date:   Wed Nov 6 12:36:36 2019 -0800

    Merge pull request #4339 from RosettaCommons/ramyarangan/segid_fix
    
    Ramyarangan/segid fix

commit fa7471d5c03cfdb2285a51ee01c557191d78937e
Merge: fc8ab40 71db386
Date:   Wed Nov 6 13:41:44 2019 -0600

    Merge pull request #4336 from RosettaCommons/roccomoretti/clang_tidy_test_fixes2
    
    Fix the `bugprone` series of clang-tidy tests.
    
    This PR enables testing for (and fixing the existing cases of) the series of "bugprone" tests which clang-tidy tests for.
    
    Mostly this was copy constructors which weren't calling their base class's copy constructor.

commit fc8ab401178f6f099884fd5a39597b1a9cac8db2
Merge: 94476f9 9fdb124
Date:   Tue Nov 5 15:46:43 2019 -0700

    Merge pull request #4341 from RosettaCommons/benchmark
    
    Adding `--disable-new-dtags` linker option to default GCC settings, this should allow proper linking to Rosetta sqlite on Ubuntu.

commit 94476f921d05cc5c2eca2c888dab565ea63babc3
Merge: 8f6da86 25c7f68
Date:   Tue Nov 5 15:40:25 2019 -0500

    Merge pull request #4344 from RosettaCommons/vmullig/fix_gcc_9_2_for_scope_warning
    
    Remove the -ffor-scope option from gcc 9.2 compilation.  This flag is deprecated in newer gcc.

commit 8f6da86c3b298344bd88373555fdc18e1b3ca486
Merge: d2034fb 47980f9
Date:   Tue Nov 5 10:10:55 2019 -0600

    Merge pull request #4330 from RosettaCommons/SamuelSchmitz/PyRosetta_WrapperFuncs
    
    Adding python wrappers for Tag::getOption (bool, int, string, real)

commit d2034fb7fe198e85b69778a08d00efcd27d105c6
Merge: 23e40ee 088ade6
Date:   Mon Nov 4 15:18:55 2019 -0700

    Merge pull request #4331 from RosettaCommons/sergey/binder
    
    - updating PyRosetta so it could be build with GCC-9
    - updating Binder to use LLVM-6,
    - fixing has_insertion_operator dependency cycle
    - enabling bindings generation for abstract base classes even when they can not be derived-from in Python

commit 23e40ee7497985dbb5787ce1f4b59f1c204102a8
Merge: 410380c 1d15ff1
Date:   Mon Nov 4 16:01:08 2019 -0600

    Merge pull request #4334 from RosettaCommons/roccomoretti/pyrosetta_zeromq_autoupdate
    
    Update the PyRosetta build.py to automatically update the zeromq submodule.
    
    If we need the zeromq module to build PyRosetta, make sure it's updated.

commit 410380c2d518abd3548c242c275f57c3ae6c4d1c
Merge: 3c41adc fe47c05
Date:   Mon Nov 4 13:14:37 2019 -0800

    Merge pull request #4089 from RosettaCommons/vmullig/multithreaded_packer_setup2
    
    Multi-thread packer setup using the RosettaThreadManager work vector interface
    
    This pull request replaces pull request #3964.
    
    A current challenge is figuring out how to get all of the existing Rosetta protocols to take advantage of parallel processing, with as little burden placed on the user as possible.  Much of the time in a typical Rosetta run is spent on:
    - Computing interaction graphs (easy to parallelize).
    - Running packing trajectories (hard to parallelize).
    - Computing gradient vectors and inverse Hessian approximations for minimization (easy to parallelize).
    - Computing the scoring function (somewhat hard to parallelize).
    - Computing kinematics (may be parallelizable?)
    
    This pull request aims to address the first point: it will allow interaction graphs to be calculated using the `RosettaThreadManager`'s thread pool, implemented in pull request #3946.  The `RosettaThreadManager` is intended to allow us to experiment with parallelizing things on many different levels in Rosetta (from apps to job distributors to movers, down to low-level components like the packer, minimizer, and scoring machinery), without having things that call things that call things create thread explosions.  (So, for example, Rosetta could launch 16 threads, the job distributor could request parallel job execution in 4 threads, and each parallel job thread could request up to 16 threads for packing, receiving 1 to 13 depending on availability so that the global pool never exceeds 16 running threads.  Note that switching the `MultithreadedJobDistributor` to use the `RosettaThreadManager` will be for a future pull request.)  It also allows very finely-grained threading, without having to encapsulate atomistic tasks in jobs that might have more overhead than the tasks themselves (as would be the case if we wanted to consider individual entries in the interaction graph calculation as "jobs").
    
    Tasks:
    - [ ] **FIX PYROSETTA DISTRIBUTED ISSUE**
    - [x] Pull request #4310 must be merged before this one.
    - [x] Pull request #3946 must be merged before this one.
    - [x] Pull request #3957 must be merged before this one.
    - [x] Add option (flag) for default number of threads that the packer will request.
         - [x] Ensure that `fixbb` respects the option.
         - [x] Test `fixbb`.
         - [x] Ensure that the `PackRotamersMover` respects the option by way of TaskOperations.
         - [x] Test `PackRotamersMover`.  (Update test).
              - [x] Ensure that the test checks that the single- and multi-threaded PDB output is identical.
         - [x] Ensure that `FastRelax` respects the option by way of TaskOperations.
         - [x] Ensure that `FastDesign` respects  the option by way of TaskOperations.
         - [x] Test `FastDesign`.  (Update test).
         - [x] Update the no-threads case in the `FastDesign` and `PackRotamersMover` tests.
    - [x] ~~Modify `PackRotamersMover`:~~
         - [x] ~~Add `MultithreadedMover` class that derives from `Mover` class.~~
         - [x] ~~Have `MultithreadedMover` take an XML-configurable option for number of threads to request.~~
         - [x] ~~Make the `PackRotamersMover` a `MultithreadedMover`, with its "number of threads" option overriding the global default if and only if provided by the user.~~
         - [x] ~~Have the `PackRotamersMover` call the multithreaded `core::pack::pack_rotamers()` if number of threads is greater than 1.~~
    - [x] Parallelize interaction graph setup.
         - [x] Pre-identify (in a single thread) the one- and two-body interactions to be computed.
         - [x] Pre-create the nodes and edges needed (using a single thread) in the interaction graph.
         - [x] Handle the symmetric case, too -- need virtual function overrides in `SymmetricRotamerSets`.
         - [x] Modify the interaction graph to allow parallel, threadsafe computation of elements.
         - [x] Make a work vector of all onebody and twobody energies to compute, and pass it to the `RosettaThreadManager`.
         - [x] Handle the lazy IG case -- probably not much that multithreading can do, but take a look anyway. --> Can only multithread the onebody energy precalculation.  Meh.  Better than nothing.
         - [x] Integration/unit test the 1-thread case.
         - [x] Integration/unit test the multi-threaded case.
         - In the future, integration test multi-threaded packing in the context of multi-threaded job distribution.
    - [x] Looks like I've got the same rare segfault issue.  Track it down. --> Got it.  Can't call functions that finalize edges from threads.
    - [x] Integration test: confirm that interaction graphs computed in parallel are identical to interaction graphs computed in serial.
         - [x] Symmetric case, too.
    - [x] Move the `-packing:packing_threads` option to `-multi_threading:packing_threads` to keep all of these options together.
    - [x] Same for the optH threads option.
    - [x] Pilot app for performance testing.
    - [x] Switch tracer output to debug output, or remove entirely.
    - [x] Special-case the logic for 1 thread requested to use the non-threaded code.
         - [x] Do this for `SymmetricRotamerSets`, too.
    - [x] Fix the twobody energy calculation for the symmetric case.
    - [x] Handle the case of threads requested in a non-threaded build.
    - [x] **FIX PYROSETTA DISTRIBUTED ISSUE.**
    - [ ] Developer documentation.
    - [ ] User documentation.
    - [x] Beauty.
    
    TODO:
    - [x] Make commandline flag more specific (`-interaction_graph_threads` instead of `packing_threads`.)
    - [x] Take out new options from hydrate, FastRelax, FastDesign, PackRotamerMover, etc. for threads.  Instead...
    - [x] Add a new TaskOperation for setting number or threads.
         - [x] PackerTask stores number of threads to request for interaction graph setup.
         - [x] Maintain commutativity: taskop can only REDUCE the number of threads.
         - [x] Have default behaviour be to use all available threads.
         - [x] Switch integration tests to use this.
    - [x] See note about Andrew's suggestion for removing code duplication; using work vector even in non-threaded build.
         - [x] Allow thread manager to be called in threaded or non-threaded build.
         - [x] Ensure that thread manager just executes the work that it is given (single-threaded) in the non-threaded build.
    - ~~Add to correctness test at least one score value.  (Especially in symmetric case.)~~ --> Already in unit tests.
    - [x] Pull construction of temporary rotamer sets in symmetry code out of the precomputation and into the work vector work units (so that they don't persist).
    - [x] Scrap the MultithreadedMover base class.  For now, TaskOperations are the way to go; later, if we have multithreaded movers, we can add utility functions for their setup rather than having a base class for it.
    
    At some point in the future:
    - At some point, remove the default thread counts from `core/util/disulfide_util.hh`, find everything that fails to compile, and switch it all to explicitly request threads.
    - At some point, remove the default thread counts from `core/pack/pack_rotamers.hh`, find everything that fails to compile, and switch it all to explicitly request threads.
    - At some point, remove the default thread counts from `core/util/SwitchResidueTypeSet.hh`, find everything that fails to compile, and switch it all to explicitly request threads.

commit 3c41adcd8df244725843f514e876e589c126030e
Merge: ec14c2c 6d7c0cf
Date:   Mon Nov 4 13:47:54 2019 -0600

    Merge pull request #4333 from RosettaCommons/SamuelSchmitz/pyrosetta_init
    
    Use shlex to split options and extra_options only if required

commit ec14c2c803348809720b3b5b1b61cdccfcd25899
Merge: a4daa29 70e8e59
Date:   Sun Nov 3 18:35:48 2019 -0800

    Merge pull request #4296 from RosettaCommons/everyday847/general_monomer_sampler
    
    Adds a stepwise sampler and infrastructure for general polymers

commit a4daa29c8dc6c28a12ca04fcdd855ce8f76f5ce3
Merge: 7b20d84 b876320
Date:   Sun Nov 3 18:26:38 2019 -0800

    Merge pull request #4337 from RosettaCommons/rpavlovicz/NCAA_disulfide
    
    fixing a bug in the get_ssbond_record function of PoseToStructFileRep…

commit 7b20d843d84b613ac95185d811994318f6378b4f
Merge: 00b2dda ff0c6e6
Date:   Sun Nov 3 15:27:44 2019 -0800

    Merge pull request #3575 from RosettaCommons/vmullig/update_dump_trajectory_energy
    
    Allow easy visualization of packing trajectories
    
    A while back, Brian Coventry added a clever means of visualizing minimization trajectories: the DumpTrajectoryEnergy.  This is a scoring term that sneakily writes out a PDB whenever it is called to evaluate derivatives.  This pull request modifies this scoreterm so that it can also dump out scoring trajectories (e.g. to visualize the _ab initio_ application's sampling) or packing trajectories.
    
    Tasks:
    - [x] Correct the access to the options system.  (Use proper options constructor).
         - [x] Add XML setup.
    - [x] Add option for "stride", so that we don't have to dump every function evaluation, but could do, for example, every 10th or 100th or 100th.
         - ~~Add separate strides for packing, minimizing, and scoring.~~
    - [x] Add support for scoring.
    - [x] Add support for packing.
    - [x] Errors if we try to interrupt a packing or minimizing trajectory (since there _are_ end-of-trajectory signals).
    - [x] Fix unit test failure.
    - [x] Fix integration test failure.
    - [x] Integration test for packing.
    - [x] Documentation: added here https://www.rosettacommons.org/docs/wiki/scripting_documentation/RosettaScripts/RosettaScripts#rosettascript-sections_scorefunctions_a-utility-scoreterm-for-trajectory-visualization.
    - [x] Beauty.
    
    This pull request also adds some configuration for the VSCode IDE, to make it work a bit more smoothly with Rosetta's massive codebase.  Users should be able to navigate to the Rosetta/main/source directory and simply type "code ." to have full editing capabilities, with Intellisense and all that good stuff.

commit 00b2ddab2d4f71f2161245c98cbaa3e8e5fd19dc
Merge: 0924b7e 7883db0
Date:   Sat Nov 2 16:45:46 2019 -0700

    Merge pull request #4332 from RosettaCommons/hahnbeom/gadock_bugfix_zero_phores
    
    add a logic to pass pharmacore match if no phore match is found

commit 0924b7ecfe83abac02c419c8c8d4f1bb261b6a71
Merge: dc7a49c 88c28b7
Date:   Thu Oct 31 15:36:58 2019 -0700

    Merge pull request #4335 from RosettaCommons/vmullig/int_to_size_in_string_util
    
    Fixing bug that was preventing read of some large text files.
    
    In our string utilities, we have a function that reads in a text file and returns a string with the file's contents. This function reserves space based on the number of characters read in. This count was unfortunately being stored in a standard, signed int, which meant that long text files could result in overflow and a negative value being passed to string::reserve(). This corrects this by switching the integer to a platform::Size, which guarantees that the number of numbers that can be stored is greater than or equal to the maximum size of string that you could store.

commit dc7a49ce5d95aa6f15137abf04f484afd48afa3a
Merge: 5aed75f 0319b07
Date:   Thu Oct 31 10:50:00 2019 -0500

    Merge pull request #4290 from RosettaCommons/roccomoretti/bugprone-integer-division_fix
    
    Fix clang-tidy bugprone-integer-division
    
    Dividing two integers in C++ gives a (truncated) integer result. This may not be what you want. Clang-tidy has a check to see if you're doing an integer division and then using the result as a floating point. This flags a fair number of examples in Rosetta, some of which are obvious bugs.
    
    I've attempted to fix the instances which clang-tidy flags, mainly by converting them to actual floating point results. This may not be the best way to fix some of these, so feel free to adjust such that the intent is clearer. See https://github.com/RosettaCommons/main/pull/4290 for detailed discussion.

commit 5aed75f2e796a33ab71515b6c1daa321eb2294a2
Merge: 8733563 01a99e6
Date:   Tue Oct 29 08:37:43 2019 -0400

    Merge pull request #4327 from RosettaCommons/rfalford12/find-optimal-hydrophobic-thk
    
    Adding application for finding the lowest energy hydrophobic thickness

commit 8733563663c9768b85914fe7b3101ddd5d864424
Merge: a218aa3 f5c714c
Date:   Fri Oct 25 23:03:02 2019 -0400

    Merge pull request #4325 from RosettaCommons/vmullig/tweak_simple_cycpep_predict_sci_test_cutoffs
    
    Tweak simple_cycpep_predict sci test cutoffs a wee bit.
    
    Some of these are a bit too lax at the moment.  Based on the last half-dozen or so runs, I'm making them a little bit more stringent.

commit a218aa31552b99fb053075ad6a19c5d073adc8dd
Merge: f98f7fb 123cce5
Date:   Fri Oct 25 15:47:34 2019 -0700

    Merge pull request #4324 from RosettaCommons/rpavlovicz/ddg_fixes
    
    Rpavlovicz/ddg fixes

commit f98f7fbbce6b021d9609c8671c860437deceadd1
Merge: 91a31ac 8a8da34
Date:   Fri Oct 25 11:45:41 2019 -0700

    Merge pull request #4323 from RosettaCommons/dimaio/hybridize_bugfixes
    
    Two hybridize fixes

commit 91a31acab4e4457779da7a4bf5fd077ad6c6e126
Merge: 144630b 6f23a60
Date:   Fri Oct 25 10:12:21 2019 -0500

    Merge pull request #4321 from RosettaCommons/jadolfbr/fix_pyr_multi
    
    Patch PyRosetta build for multithreading - from Alex Ford.

commit 144630bd1ecd26808a9f070798c067f4196109ab
Merge: 91b4d2d d1cbce5
Date:   Thu Oct 24 18:56:06 2019 -0400

    Merge pull request #4322 from RosettaCommons/BYachnin/fix_quality_clang_tidy_tests
    
    Fixing the ubuntu.clang.code_quality.clang_tidy test breakages introduced by my recent merge.
    
    Here's the broken test: https://b3.graylab.jhu.edu/test/562923
    Here's the test for this revision: https://b3.graylab.jhu.edu/test/563115

commit 91b4d2d1beee08f2fa6245a80e63a0a503e94307
Merge: a8ba3f1 5d7bb6a
Date:   Thu Oct 24 16:24:27 2019 -0400

    Merge pull request #4295 from RosettaCommons/vmullig/rocco_fix_to_hbond_geom
    
    Picking Rocco's fix to hbonds_geom.cc out of roccomoretti/bugprone-integer-division_fix.
    
    Description:
    
    In pull request #4290, Rocco has identified a number of places in which we have likely been making division errors by assuming that an integer divided by an integer gives a floating-point number (which it does not). These are bugs that need to be fixed. Unfortunately, at least one likely has implications for scoring or minimization. This is the change most likely to cause unit, integration, and scientific test changes, so I think it makes sense to test it and merge it entirely separately. I want to be sure that this is a change that we can make without re-calibrating the whole scoring function.
    
    Notes on the current scientific test failures and changes:
    
    --    make_fragments, RosettaCM, and glycan_structure_prediction are all failures-to-run because they're not yet in the current master.
    --    dock_glycans and mp_symdock fail in the same way as they do currently in master.
    --    Looking at fast_relax_5iter (which passes), I notice no remarkable qualitative difference from current master. (There are no large changes in the scores or score ranges, for example).
    --    Looking at antibody_snugdock (which passes), there are big jumps in the discrimination score, but I gather that this happens from run to run anyways. The plots look qualitatively similar.
    --    The simple_cycpep_predict test does a lot of sampling. Again, the E vs. RMSD lots look qualitatively very similar.
    --    All tests passing in master pass in this branch.
    
    Based on the scientific test results (https://b3.graylab.jhu.edu/revision/commits/13892), I'm pretty convinced that this change to scoring is sufficiently benign that we don't need to worry about recalibrating everything or about it invalidating scientific performance.

commit a8ba3f14cdbce927c363dc259314d999b150b7bf
Merge: b6a2dfe d418899
Date:   Thu Oct 24 10:38:54 2019 -0700

    Merge pull request #4315 from RosettaCommons/dimaio/fix_hybrid_max_contig_insertion_option
    
    Fixing the behavior of max_contig_insertion in HybridizeMover.

commit b6a2dfe73d33f4470f10508d2305c7efba895c8d
Merge: abb32da 671ce7b
Date:   Thu Oct 24 09:32:51 2019 -0500

    Merge pull request #4319 from RosettaCommons/everyday847/pdb_components_update
    
    update components

commit abb32da021840d6f5ab2a26e276a79f80f764bb7
Merge: eea4e61 cf7f384
Date:   Wed Oct 23 16:04:05 2019 -0700

    Merge pull request #3244 from RosettaCommons/rpavlovicz/water_branch_updates
    
    Updates to the beta_nov16 statistical water protocols.

commit eea4e61f586436116731ff0b57bc08afe6cf9d7a
Merge: 068da34 e9925e8
Date:   Tue Oct 22 19:36:09 2019 -0400

    Integrate nmer into mhc_epitope to allow packer-compatibility
    
    The "established" mechanism for de-immunizing proteins in Rosetta is using the NMerSVMEnergy class implemented by @indigogo . In contrast to MHCEpitopeEnergy, NMer is not inherently packer compatible.
    
    This PR essentially adds a new MHCEpitopePredictor that allows nmer to be packer-compatible, using the framework we established with mhc_epitope. While the SVM-based scoring is rather slow using the current SVMs, the common framework could still be used to score proteins outside of the context of the packer. In addition, if faster SVMs are added (or generated by the user), they could be used in a packer-compatible manner.
    
    In order to implement this, a few changes to both the MHCEpitopeEnergy class and the NMer classes needed to be made. Testing has not shown any changes triggered by these changes. (The failure for mhc_epitope_nmer_preload is expected, as the test was changed to introduce nmer stuff.  The failure for mhc_epitope is cosmetic.)
    
    In addition to the nmer integration itself, this PR also makes some under-the-hood changes:
    -MHCEpitopeEnergy now handles Predictors that work using a core + potentially missing overhang definition of their peptides, where the "overhang" regions could hang off the end of the peptide chain.  This is different from cases where the entire peptide is "core," meaning that some peptides at the end of the chain would not be counted.  NetMHCII dealt with this internally, but nmer does not, so it was needed for equivalent treatment.  Extendable to other Predictors that use this strategy.
    -Disk reads are now all handled by the ScoringManager, which should improve performance in certain cases.
    -Some things got moved around to address the split of `core.3` which took place some months ago.
    
    Thanks to @indigogo for originally writing the nmer code, and @vmullig for review (and particularly suggesting the ScoringManager improvements).

commit 068da34a45be898ebdc2088dd0dc225750bf7465
Merge: 0d1acbb c1fe4c9
Date:   Tue Oct 22 12:22:27 2019 -0700

    Merge pull request #4314 from RosettaCommons/danpf-rosetta-es-patch-1
    
    python2->3 bug in rosettaES script

commit 0d1acbb9263c0a1282a9feb999ebe07cb03edb4b
Merge: 56cd6b2 29ced73
Date:   Tue Oct 22 10:56:29 2019 -0700

    Merge pull request #4317 from RosettaCommons/bcov/FixZeroMQ
    
    Fix ZeroMQ build

commit 56cd6b218e5564ec551b8e5a19c781ab195b7817
Merge: 61da2f7 4a1e7a9
Date:   Tue Oct 22 10:34:59 2019 -0500

    Merge pull request #4308 from RosettaCommons/roccomoretti/reorganize_rosettascript_handling
    
    Reorganize RosettaScriptsParser tag handling.
    
    RosettaScriptsParser::generate_mover_for_protocol() was a bit of a muddle. Break out the detailed handling into sub-functions. Also, iterate through the subtags once, in order, rather than in multiple stages.
    
    * This may cause issues for some existing RosettaScripts, which (incorrectly) rely on having sections like RESIDUE_SELECTORS or SCOREFUNCTIONS _after_ the mover/filter section which use them. These should be rare, and can be fixed by reordering the tags. (Remembering you can repeat sections.)

commit 61da2f786e1882934861d83f906ea33689ef732f
Merge: ec11121 7d9a69c
Date:   Mon Oct 21 18:23:10 2019 -0400

    Merge pull request #4311 from RosettaCommons/vmullig/make_orient_function_const
    
    Identified a function that can and should be const.
    
    This was a small mistake corrected in a much longer pull request which might not make its way into master for a while. I want to make sure that this change goes in now, since any changes to this function that would prevent it from being const would mess up what I'm doing in that branch.

commit ec1112147072181ace4227b58071a2538d3122ef
Merge: c0544d9 e47a30e
Date:   Mon Oct 21 17:56:16 2019 -0400

    Merge pull request #4313 from RosettaCommons/vmullig/relax_peptoid_check
    
    Allow the simple_cycpep_predict -user_set_alpha_dihedrals flag to work for peptoids, too.

commit c0544d95c0f4110010c2fcbea66e45c4187b4600
Merge: cd6329a 0c0e0d2
Date:   Mon Oct 21 15:56:06 2019 -0500

    Merge pull request #4304 from RosettaCommons/jadolfbr/fix_insert_conf_by_jump
    
    This is a simple change that clears the `GlycanTreeSet` and observers at the beginning of the `insert_conformation_by_jump` function, and then sets it up at the end.  This is due to the way this function deals with observers - instead of adding a residue, and then calling residue append, it adds ALL residues to the pose and THEN calls residue append for all the residues at the end.

commit cd6329a1c338c2e118a4c2a4db14234ea0812357
Merge: fdd9c13 b5e9083
Date:   Mon Oct 21 13:46:08 2019 -0600

    Merge pull request #4306 from RosettaCommons/sergey/b3
    
    Updating benchmark.py script so it could work with B3 back-end daemon

commit fdd9c139c7ac01d67df5494f1edd795d308ea490
Merge: 3666509 f9b5e8c
Date:   Mon Oct 21 10:40:29 2019 -0700

    Merge pull request #4264 from RosettaCommons/bcov/ApproxNat1AndDunbrack
    
    ApproximateBuriedUnsat upgrades and -dunbrack_prob_semi flags