Relax 3.3.6

Official relax releases

relax version 3.3.6
Previous version Next version ← relax 3.3.5 relax 3.3.7 →
Release type	Minor feature and bugfix
Release date	4 February 2015
The relax 3.3.6 user manual

Description

This is a minor feature and bugfix release. It includes the addition of the new structure.sequence_alignment user function which can use the 'Central Star' multiple sequence alignment algorithm or align based on residue numbers, saving the results in the relax data store. The assembly of structural coordinates used by the structure.align, structure.atomic_fluctuations, structure.com, structure.displacement, structure.find_pivot, structure.mean, structure.rmsd, structure.superimpose and structure.web_of_motion user functions has been redesigned around this new user function. It will use any pre-existing sequence alignments for the molecules of interest, use no sequence alignment if only structural models are selected, and default to a residue number based alignment if the structure.sequence_alignment user function has not been used. Bug fixes include a system test failure on Mac OS X, and I_∞ parameter text files and Grace graphs are now produced by the relaxation curve-fitting auto-analysis for the inversion recovery and saturation recovery experiment types. Many more details are given below.

Download

The new relax versions can be downloaded from http://www.nmr-relax.com/download.html. If binary distributions are not yet available for your platform and you manage to compile the binary modules, please consider contributing these to the relax project (described in section 3.6 of the relax manual, http://www.nmr-relax.com/manual/relax_distribution_archives.html).

CHANGES file

Version 3.3.6
(4 February 2015, from /trunk)
http://svn.gna.org/svn/relax/tags/3.3.6

Features

• The Needleman-Wunsch sequence alignment algorithm now calculates an alignment score.
• Implementation of the central star multiple sequence alignment (MSA) algorithm.
• Implementation of a reside number based multiple sequence alignment (MSA) algorithm.
• Large speed up of the molecule, residue, and spin selection object, affecting all parts of relax.
• Sequence alignments are now saved in the relax data store.
• Important formatting improvement for the description in the GUI user function windows, removing excess empty lines after lists.
• Creation of the structure.sequence_alignment user function. The MSA algorithm can be set to either 'Central Star' or 'residue number', the pairwise sequence alignment algorithm to 'NW70' for the Needleman-Wunsch algorithm, and the substitution matrix to one of 'BLOSUM62', 'PAM250', or 'NUC 4.4'.
• More advanced support for different numpy number types in the lib.xml relax library module. This allows numpy int16, int32, float32, and float64 objects to be saved in the relax data store and retrieved from relax XML save and results files.
• Merger of structure.align into the structure.superimpose user function.
• The assembly of common atomic coordinates by the structure user functions now takes sequence alignments into account. The logic is to first use a sequence alignment from the relax data store if present, use no sequence alignment if coordinates only come from structural models, or fall back to a residue number based alignment. This affects the structure.align, structure.atomic_fluctuations, structure.com, structure.displacement, structure.find_pivot, structure.mean, structure.rmsd, structure.superimpose and structure.web_of_motion user functions.
• Large improvements in the memory management for all parts of the GUI.

Changes

• Spelling fixes for the CHANGES document.
• Created the Structure.test_align_molecules2 system test. This is to demonstrate a failure condition in the structure.align user function.
• Large simplification of the atomic coordinate assembly code in the internal structural object. This is in the lib.structure.internal.coordinates.assemble_coord_array() function. The logic of the function has recently changed due to the introduction of the pairwise sequence alignments. This caused a lot of code to now be redundant, and also incorrect in certain cases. This simplification fixes the problem caught by the Structure.test_align_molecules2 system test.
• Fix for the Structure.test_displacement system test - the molecule IDs needed updating.
• Created the Structure.test_align_molecules_end_truncation system test. This is to demonstrate a failure of the common residue detection algorithm using multiple pairwise alignments in the backend of the structure.align and other multiple structure based user functions.
• Created empty unit test infrastructure for testing the lib.structure.internal.coordinates module.
• Created the Test_coordinates.test_common_residues unit test. This is from the _lib._structure._internal.test_coordinates unit test module. The test shows that the lib.structure.internal.coordinates.common_residues() function is working correctly. However the printout, which is not caught by the test, is incorrect.
• Modified the lib.structure.internal.coordinates.common_residues() function. It now accepts the seq argument which will caused the gapped sequence strings to be returned. This is to allow for checking in the unit tests.
• Created the Test_align_protein.test_align_multiple_from_pairwise unit test. This is in the _lib._sequence_alignment.test_align_protein unit test module. This test checks the operation of the lib.sequence_alignment.align_protein.align_multiple_from_pairwise() function, which does not yet exist.
• Simplified the Test_coordinates.test_common_residues unit test by removing many residues. This is from the _lib._structure._internal.test_coordinates unit test module.
• Expanded the docstring of the Test_align_protein.test_align_multiple_from_pairwise unit test. This is from the _lib._sequence_alignment.test_align_protein unit test module.
• Attempt at fixing the lib.structure.internal.coordinates.common_residues() function. This function still does not work correctly.
• Renamed the Test_align_protein.test_align_multiple_from_pairwise unit test. This is now the Test_msa.test_central_star unit test of the _lib._sequence_alignment.test_msa unit test module (it was originally in the _lib._sequence_alignment.test_align_protein unit test module). This is in preparation for converting the lib.sequence_alignment.align_protein.align_multiple_from_pairwise() function into the lib.sequence_alignment.msa.central_star() function.
• Added the lib.sequence_alignment.align_protein.align_multiple_from_pairwise() function. This should have been committed earlier. The function is only partly implemented.
• Initial lib.sequence_alignment.msa.central_star() function. This was moved from lib.sequence_alignment.align_protein.align_multiple_from_pairwise().
• Import fix for the _lib._sequence_alignment.test_align_protein unit test module.
• Added the verbosity argument to lib.sequence_alignment.align_protein.align_pairwise(). If set to zero, all printouts are suppressed.
• The Needleman-Wunsch sequence alignment algorithm now calculates and returns an alignment score. This is in the lib.sequence_alignment.needleman_wunsch.needleman_wunsch_align() function. The score is calculated as the sum of the Needleman-Wunsch matrix elements along the traceback path.
• The protein pairwise sequence alignment function now returns the alignment score. This is in the lib.sequence_alignment.align_protein.align_pairwise() function. The score from the Needleman-Wunsch sequence alignment algorithm is simply passed along.
• Fix for the Test_msa.test_central_star unit test. This is from the _lib._sequence_alignment.test_msa unit test module. Some of the real gap matrix indices were incorrect.
• Complete implementation of the central star multiple sequence alignment algorithm. This includes all the four major steps - pairwise alignment between all sequence pairs, finding the central sequence, iteratively aligning the sequences to the gapped central sequence, and introducing gaps in previous alignments during the iterative alignment. The correctness of the implementation is verified by the Test_msa.test_central_star unit test of the _lib._sequence_alignment.test_msa module.
• Fixes for the unit tests of the _lib._sequence_alignment.test_align_protein module. The Test_align_protein.test_align_pairwise_PAM250 unit test was accidentally duplicated due to a copy and paste error. And the lib.sequence_alignment.align_protein.align_pairwise() function now also returns the alignment score.
• Fixes for the unit tests of the _lib._sequence_alignment.test_needleman_wunsch module. The lib.sequence_alignment.needleman_wunsch.needleman_wunsch_align() function now returns the alignment score.
• The assemble_coord_array() function is now using the central star multiple sequence alignment. This is the function from the lib.structure.internal.coordinates module used to assemble common atomic coordinate information, used by the structure.align, structure.atomic_fluctuations, structure.com, structure.displacement, structure.find_pivot, structure.mean, structure.rmsd, structure.superimpose and structure.web_of_motion user functions. The non-functional lib.structure.internal.coordinates.common_residues() function has been removed as the lib.sequence_alignment.msa.central_star() function performs this functionality correctly.
• Deleted the Test_coordinates.test_common_residues unit test. This is from the _lib._structure._internal.test_coordinates unit test module. The lib.structure.internal.coordinates.common_residues() function no longer exists.
• Alphabetical ordering of all Structure system tests.
• Better printout spacing in lib.sequence_alignment.msa.central_star().
• Fixes for the Structure.test_align_molecules_end_truncation system test. This system test had only been partly converted from the old Structure.test_align_molecules2 system test it had been copied from.
• Created the Internal_selection.count_atoms() internal structural object selection method. This counts the number of atoms in the current selection.
• Added final printouts to the structure.rotate and structure.translate user function backends. This is to give feedback to the user as to how many atoms were translated or rotated, to aid in solving problems with the structure user functions. These backend functions are also used by the structure.align and structure.superimpose user functions.
• Corrections for the Structure.test_align_CaM_BLOSUM62 system test. The CaM N and C domains can not be aligned together in a global MSA as they would align very well to themselves, causing the atomic coordinate assembly function to fail.
• Improvement for the lib.sequence_alignment.msa.central_star() function. The strings and gap matrix returned by the function have been reordered to match the input sequences.
• Modified the Structure.test_align_molecules_end_truncation system test. The calmodulin bound calciums are now deleted prior to the structure.align user function call. This prevents these being labelled as '*' residues and aligning with real amino acids via the central star multiple sequence alignment (MSA) algorithm.
• Large speed up of the mol-res-spin selection object. The Selection.contains_mol(), Selection.contains_res() and Selection.contains_spin() methods of the lib.selection module have been redesigned for speed. Instead of setting a number of flags and performing bit operations at the end of the method to return the correct Boolean value, each of the multiple checks now simply returns a Boolean value, avoiding all subsequent checks. The check list order has also been rearranged so that the least expensive checks are to the top and the most time intensive checks are last.
• Created the new relax data store object for saving sequence alignments. This is in the new data_store.seq_align module via the Sequence_alignments object, subclassed from RelaxListType, for holding all alignments and the Alignment Element object, subclassed from Element, for holding each individual alignment. The objects are currently unused.
• Added the seq_align module to the data_store package __all__ list.
• Created the Test_seq_align.test_alignment_addition unit test. This is in the _data_store.test_seq_align unit test module. This tests the setup of the sequence alignment object via the data_store.seq_align.Sequence_alignment.add() method.
• Fixes for the data_store.seq_align.Alignment.generate_id() method. These problems were identified by the _data_store.test_seq_align module Test_seq_align.test_alignment_addition unit test.
• Added the Test_seq_align.test_find_alignment and Test_seq_align.test_find_missing_alignment unit tests. These are in the _data_store.test_seq_align unit test module. They check the functionality of the currently unimplemented Sequence_alignment.find_alignment() method which will be used to return pre-existing alignments.
• Code rearrangement in the _data_store.test_seq_align unit test module. The ID generation has been shifted into the generate_ids() method to be used by multiple tests.
• Implemented the data_store.seq_align.Sequence_alignments.find_alignment() method. This will only return an alignment if all alignment input data and alignment settings match exactly.
• Shifted the data_store.seq_align.Alignment.generate_id() method into the relax library. It has been converted into the lib.structure.internal.coordinates.generate_id() function to allow for greater reuse.
• Created the Sequence.test_align_molecules system test. This will be used to implement the sequence.align user function which will be used for performing sequence alignments on structural data within the relax data store and storing the data in the data pipe independent sequence_alignments data store object (which will be an instance of data_store.seq_align.Sequence_alignments). The system test also checks the XML saving and loading of the ds.sequence_alignments data structure.
• Renamed the Sequence.test_align_molecules system test to Structure.test_sequence_alignment_molecules. As the sequence alignment is dependent on the structural data in the relax data store, the user function for sequence alignment would be better named as structure.sequence_alignment. The sequence.align user function is not appropriate as all other sequence user functions relate to the molecule, residue, and spin data structure of each data pipe rather than to the structural data.
• Modified the Structure.test_sequence_alignment_molecules system test. Changed and expanded the arguments to the yet to be implemented structure.sequence_alignment user function.
• Important formatting improvement for the description in the GUI user function windows. Previously lists, item lists, and prompt items were spaced with one empty line at the top and two at the bottom. The two empty lines at the bottom was an accident caused by how the list text elements were built up. Now the final newline character is stripped so that the top and bottom of the lists only consist of one empty line. The change can give a lot more room in the GUI window.
• Created the frontend for the structure.sequence_alignment user function. This is based on the structure.align user function with the 3D superimposition arguments removed and new arguments added for selecting the MSA algorithm and the pairwise alignment algorithm (despite only NW70 being currently implemented).
• Modified the assemble_coordinates() function of the pipe_control.structure.main module. The function has been renamed to assemble_structural_objects(). The call to the lib.structure.internal.coordinates.assemble_coord_array() function has also been shifted out of assemble_structural_objects() to simplify the logic and decrease the amount of arguments passed around.
• Spun out the atomic assembly code of the assemble_coord_array() function. The code from the lib.structure.internal.coordinates.assemble_coord_array() function has been shifted to the new assemble_atomic_coordinates(). This is to simplify assemble_coord_array() as well as to isolate the individual functionality for reuse.
• Implemented the backend of the structure.sequence_alignment user function. This checks some of the input parameters, assembles the structural objects then the atomic coordinate information, performs the multiple sequence alignment, and then stores the results.
• Fixes for the sequence alignment objects for the relax data store. The Sequence_alignments(RelaxListType) and Alignment(Element) classes were not being set up correctly. The container names and descriptions were missing.
• The data store ds.sequence_alignment object is now being treated as special and is blacklisted. The object is now explicitly recreated in the data store from_xml() method.
• Fixes for handling the sequence_alignments data store object.
• Implemented the data store Sequence_alignments.from_xml() method. This method is required for being able to read RelaxListType objects from the XML file.
• Modified the data returned by lib.structure.internal.coordinates.assemble_atomic_coordinates(). The function will now assemble simple lists of object IDs, model numbers and molecule names with each list element corresponding to a different structural model. This will be very useful for converting from the complicated pipes, models, and molecules user function arguments into relax data store independent flat lists.
• Updates for the structure.sequence_alignment user function. This is for the changes to the lib.structure.internal.coordinates.assemble_atomic_coordinates() function return values. The new object ID, model, and molecule flat lists are used directly for storing the alignment results in the relax data store.
• Updates for the Structure.test_sequence_alignment_molecules system test. This is required due to the changes in the backend of the structure.sequence_alignment user function.
• Merger of the structure.align and structure.superimpose user functions. The final user function is called structure.superimpose. As the sequence alignment component of the structure.align user function has been shifted into the new structure.sequence_alignment user function and the information is now stored in ds.sequence_alignments relax data store object, the functionality of structure.align and structure.superimpose are now essentially the same. The sequence alignment arguments and documentation has also been eliminated. And the documentation has been updated to say that sequence alignments from structure.sequence_alignment will be used for superimposing the structures.
• Updated the Structure system tests for the structure.align and structure.superimpose user function merger.
• Fix for the structure.sequence_alignment user function. The alignment data should be stored in ds.sequence_alignments rather than ds.sequence_alignment.
• Sequence alignments can now be retrieved without supplying the algorithm settings. This is in the data_store.seq_align.Sequence_alignments.find_alignment() method. The change allows for the retrieval of pre-existing sequence alignments at any stage.
• Added a function for assemble the common atomic coordinates taking sequence alignments into account. This is the new pipe_control.structure.main.assemble_structural_coordinates() function. It takes the sequence alignment logic out of the lib.structure.internal.coordinates.assemble_coord_array() function so that sequence alignments in the relax data store can be used. The logic has also been redefined as: 1, use a sequence alignment from the relax data store if present; 2, use no sequence alignment if coordinates only come from structural models; 3, fall back to a residue number based alignment. The residue number based alignment is yet to be implemented. As a consequence, the lib.structure.internal.coordinates.assemble_coord_array() function has been greatly simplified. It no longer handles sequence alignments, but instead expects the residue skipping data structure, built from the alignment, as an argument. The seq_info_flag argument has also been eliminated in this function as well as the pipe_control.structure.main module.
• Updated the structure.displacement user function for the changed atomic assembly logic. This now uses the assemble_structural_coordinates() function of the pipe_control.structure.main module to obtain the common coordinates based on pre-existing sequence alignments, no-alignment, or the default of a residue number based alignment.
• Updated the structure.find_pivot user function for the changed atomic assembly logic. This now uses the assemble_structural_coordinates() function of the pipe_control.structure.main module to obtain the common coordinates based on pre-existing sequence alignments, no-alignment, or the default of a residue number based alignment.
• Updated the structure.atomic_fluctuations user function for the changed atomic assembly logic. This now uses the assemble_structural_coordinates() function of the pipe_control.structure.main module to obtain the common coordinates based on pre-existing sequence alignments, no-alignment, or the default of a residue number based alignment.
• Updated the structure.rmsd user function for the changed atomic assembly logic. This now uses the assemble_structural_coordinates() function of the pipe_control.structure.main module to obtain the common coordinates based on pre-existing sequence alignments, no-alignment, or the default of a residue number based alignment.
• Updated the structure.web_of_motion user function for the changed atomic assembly logic. This now uses the assemble_structural_coordinates() function of the pipe_control.structure.main module to obtain the common coordinates based on pre-existing sequence alignments, no-alignment, or the default of a residue number based alignment.
• Fix for the structure.superimpose user function if no data pipes are supplied. This reintroduces the pipes list construction.
• Fix for the new pipe_control.structure.main.assemble_structural_coordinates() function. The atom_id argument is now passed into the assemble_atomic_coordinates() function of the lib.structure.internal.coordinates module so that atom subsets are once again recognised.
• Another fix for the new pipe_control.structure.main.assemble_structural_coordinates() function. The logic for determining if only models will be superimposed was incorrect.
• Implemented the residue number based alignment in the atomic assembly function. This is in the new pipe_control.structure.main.assemble_structural_coordinates() function. The code for creating the residue skipping data structure is now shared between the three sequence alignment options.
• Implemented the multiple sequence alignment method based on residue numbers. This is the new msa_residue_numbers() function in the lib.sequence_alignment.msa module. The logic is rather basic in that the alignment is based on a residue number range from the lowest residue number to the highest - i.e. it does not take into account gaps in common between all input sequences.
• The residue number based sequence alignment is now executed when assembling atomic coordinates. This is in the assemble_structural_coordinates() function of the pipe_control.structure.main module.
• Modified the internal structural object one_letter_codes() method. This now validates the models to make sure all models match, and the method requires the selection object so that residue subsets can be handled.
• The assemble_atomic_coordinates() function now calls one_letter_codes() with the selection object. This is the lib.structure.internal.coordinates module function.
• Fix for the residue number based sequence alignment when assembling structural coordinates. This is in the assemble_structural_coordinates() function of the pipe_control.structure.main module. The sequences of the different molecules can be of different lengths.
• Shifted the residue skipping data structure construction into the relax library. The code was originally in pipe_control.structure.main.assemble_structural_coordinates() but has been shifted into the new lib.sequence_alignment.msa.msa_residue_skipping() function. This will also for greater code reuse. The lib.sequence_alignment.msa module is also a better location for such functionality.
• Renamed the Structure.test_sequence_alignment_molecules system test. The new name is Structure.test_sequence_alignment_central_star_nw70_blosum62, to better reflect what the test is doing.
• Modified the Structure.test_sequence_alignment_central_star_nw70_blosum62 system test. Some residues are now deleted so that the sequences are not identical.
• Created the Structure.test_sequence_alignment_residue_number system test. This will be used to test the structure.sequence_alignment user function together with the 'residue number' MSA algorithm. This is simply a copy of the Structure.test_sequence_alignment_central_star_nw70_blosum62 system test with a few small changes.
• Corrections and simplifications for the Structure.test_sequence_alignment_residue_number system test.
• Modified the structure.sequence_alignment user function arguments. The pairwise_algorithm and matrix arguments can no be None, and they default to None.
• Updated the Structure.test_align_CaM_BLOSUM62 system test script. The MSA algorithm and pairwise alignment algorithms are now specified in the structure.sequence_alignment user function calls.
• Creation of the lib.sequence_alignment.msa.msa_general() function. This consists of code from the structure.sequence_alignment user function backend function pipe_control.structure.main.sequence_alignment() for selecting between the different sequence alignment methods.
• The structure.sequence_alignment user function now sets some arguments to None before storage. This is for all arguments not used in the sequence alignment. For example the residue number based alignment does not use the gap penalties, pairwise alignment algorithm or the substitution matrices.
• Fix for the lib.sequence_alignment.msa.msa_residue_skipping() function. The sequences argument for passing in the one letter codes has been removed. The per molecule loop should be over the alignment strings rather than one letter codes, otherwise the loop will be too short.
• Fix for the internal structural object atomic coordinate assembly function. This is the pipe_control.structure.main.assemble_structural_coordinates() function. The case of no sequence alignment being required as only models are being handled is now functional. The strings and gaps data structures passed into the lib.sequence_alignment.msa.msa_residue_skipping() function for generating the residue skipping data structure are now set to the one letter codes and an empty structure of zeros respectively.
• Test data directory renaming. The test_suite/shared_data/diffusion_tensor/spheroid directory has been renamed to spheroid_prolate. This is in preparation for creating oblate spheroid diffusion relaxation data.
• Creation of oblate spheroid diffusion relaxation data. This will be used in the Structure.test_create_diff_tensor_pdb_oblate system test.
• Fix for the oblate spheroid diffusion relaxation data. The diffusion parameters are constrained as D_x ≤ D_y ≤ D_z.
• More fixes for the Structure.test_create_diff_tensor_pdb_oblate system test. The initial D_iso value is now set to the real final D_iso, and the PDB file contents have been updated for the fixed oblate spheroidal diffusion relaxation data.
• Updates for many of the Diffusion_tensor system tests. This is due to the changed directory names in test_suite/shared_data/diffusion_tensor/. The ds.diff_dir variable has been introduced to point to the correct data directory.
• Large improvement for the GUI test tearDown() clean up method, fixing the tests on wxPython 2.8. The user function window destruction has been shifted into a new clean_up_windows() method which is executed via wx.CallAfter() to avoid racing conditions. In addition, the spin viewer window is destroyed between tests. The spin viewer window change allows the GUI tests to pass on wxPython 2.8 again. This also allows the GUI tests to progress much further on Mac OS X systems before they crash again for some other reason. This could simply be hiding a problem in the spin viewer window. However it is likely to be a racing problem only triggered by the super fast speed of the GUI tests and a normal user would never be able to operate the GUI on the millisecond timescale and hence may never see it.
• Reverted the wxPython 2.8 warning printout when starting relax, introduced in relax 3.3.5.
• Reverted the skipping of the GUI tests on wxPython 2.8, introduced in relax 3.3.5.
• Reverted the General.test_bug_23187_residue_delete_gui GUI test disabling, introduced in relax 3.3.5. The 'Bus Error' on Mac OS X due to this test is no longer an issue, as the spin viewer window is now destroyed after each GUI test.
• Created a special Destroy() method for the spin viewer window. This is for greater control of the spin viewer window destruction. First the methods registered with the observer objects are unregistered, then the children of the spin viewer window are destroyed, and finally the main spin viewer window is destroyed. This change saves a lot of GUI resources in the GUI tests (there is a large reduction in 'User Objects' and 'GDI Objects' used on MS Windows systems, hence an equivalent resource reduction on other operating systems).
• Fix for the GUI test clean_up_windows() method called from tearDown(). The user function window (Wiz_window) must be closed before the user function page (Uf_page), so that the Wiz_window._handler_close() can still operate the methods of the Uf_page. This avoids a huge quantity of these errors: Traceback (most recent call last): __getattr__ wx._core.PyDeadObjectError: The C++ part of the Uf_page object has been deleted, attribute access no longer allowed.
• Simplification of the Dead_uf_pages.test_mol_create GUI test. The RelaxError cannot be caught from the GUI user function window, therefore the try statement has been eliminated.
• More memory saving improvements for the GUI test suite tearDown() method. The clean_up_windows() method now loops through all top level windows (frames, dialogs, panels, etc.) and calls their Destroy() method.
• Created the gui.uf_objects.Uf_object.Destroy() method. This will be used to cleanly destroy the user function object.
• Modified the GUI test suite _execute_uf() method. This user function execution method now calls the user function GUI object Destroy() method to clean up all GUI objects. This should save memory for GUI objects in the GUI test suite.
• Modified the GUI test suite tearDown() method. The clean_up_windows() method called by tearDown() now prints out a lost of all of the living windows instead of trying to destroy them (which causes the running of the GUI tests in the GUI to cause the GUI to be destroyed). The printouts will be used for debugging purposes.
• Fixes for the custom Wiz_window.Destroy() method. This will now first close the wizard window via the Close() method to make sure all of the wizard pages are properly updated. In the end the wizard DestroyChildren() method is called to clean up all child wx objects, and finally Destroy() is called to eliminate the wizard GUI object.
• The GUI test suite tearDown() method now calls the user function GUI wizard Destroy() method. This is for better handling of user function elimination.
• Fixes for the user function GUI object Destroy() method. This matches the code just deleted in the GUI test suite tearDown() method for handing the user function page object.
• More fixes for the user function GUI object Destroy() method. This page GUI object is destroyed by the wizard window Destroy() method, so destroying again causes wxPython runtime errors.
• Spacing printout for the list of still open GUI window elements. This is for the GUI test tearDown() method.
• Shifted the printouts from the GUI tests suite clean_up_windows() method to the tearDown() method. This change means that the printouts are not within a wx.CallAfter() call, but rather at the end of the tearDown() method just prior to starting the next test.
• Simplification of the GUI analysis post_reset() method. This now uses the delete_all() and hence delete_analysis() methods to clean up the GUI. The reset argument has been added to skip the manipulation of relax data store data, as the data store is empty after a reset. However the calling of the delete_analysis() method now ensures that the analysis specific delete() method is now called so that the GUI elements can be properly destroyed.
• Proper destruction of the peak analysis wizard of the NOE GUI analysis. The peak wizard's Destroy() method is now called and the self.peak_wizard object deleted in the NOE GUI analysis delete() method.
• Improved memory management in the NOE GUI analysis peak_wizard_launch() method. This method was just overwriting the self.peak_wizard object with a new object. However this does not destroy the wxPython window. Now if a peak wizard is detected, its Destroy() method is called before overwriting the object.
• Improved GUI clean up when terminating GUI tests. The clean_up_windows() method, called from tearDown(), now also destroys the pipe editor window, the results viewer window, and the prompt window. This ensures that all of the major relax windows are destroyed between GUI tests.
• Improved memory management in the relaxation curve-fitting GUI analysis. The peak intensity loading wizard is now properly destroyed. This is both via the delete() function for terminating the analysis calling the wizard Delete() method, and in the peak_wizard_launch() method calling the wizard Delete() method prior to overwriting the self.peak_wizard object with a new GUI wizard.
• Improved memory management in the model-free GUI analysis. The dipole-dipole interaction wizard is now properly destroyed. This is both via the delete() function for terminating the analysis calling the wizard Delete() method, and in the setup_dipole_pair() method calling the wizard Delete() method prior to overwriting the self.dipole_wizard object with a new GUI wizard.
• Improved memory management in the model-free GUI analysis. The analysis mode selection window (a wx.Dialog) is now being destroyed in the analysis delete() method. This appears to work on Linux, Windows, and Mac systems.
• Improved memory management in the model-free GUI analysis. The local tm and model-free model windows are now destroyed in the GUI analysis delete() method.
• Improved termination of the GUI tests. The clean_up_windows() method now calls the results viewer and pipe editor window handler_close() methods. This ensures that all observer objects are cleared out so that the methods of the dead windows can no longer be called.
• Fix for the previous commit, calls to wx.Yield() are required to flush the calls on the observer objects after unregisteristing them and deleting the results and pipe editor windows.
• Improved memory management in the relaxation dispersion GUI analysis. The peak intensity loading wizard is now properly destroyed. This is both via the delete() function for terminating the analysis calling the wizard Delete() method, and in the peak_wizard_launch() method calling the wizard Delete() method prior to overwriting the self.peak_wizard object with a new GUI wizard.
• Created custom Destroy() methods for the pipe editor and results viewer GUI windows.
• Improved memory management in the relaxation dispersion GUI analysis. The dispersion model list window is now destroyed in the GUI analysis delete() method.
• Fixes for the custom Destroy() methods for the pipe editor and results viewer GUI windows. The event argument is now a keyword argument which defaults to None. This allows the Destroy() methods to be called without arguments.
• Temporary disablement of the results viewer window destruction in the GUI tests. This currently, for some unknown reason, causes segfault crashes of the GUI tests on Linux systems.
• Changes for how the main GUI windows are destroyed by the GUI test tearDown() method. These changes revert some of the code of previous commits. The recently introduced pipe editor and results viewer windows Delete() methods have been deleted. Instead the Close() methods are called in the tearDown() method to unregister the windows from the observer objects, followed by a wx.Yield() call to flush the wx events, and then the clean_up_windows() GUI test base method is called within a wx.CallAfter() call. This avoids the racing induced segfaults in the GUI tests.
• Improved memory management in the spin viewer window. The spin loading wizard is now destroyed in the Destroy() method as well as before reinitialising the wizard in the load_spins_wizard() method.
• The GUI tests tearDown() method now prints out the Wizard windows title, if not destroyed.
• The Wizard window title is now being stored as a class instance variable.
• Improved memory management in the relaxation data list GUI element, as well as the base list object. The relaxation data loading wizard is now destroyed in the Base_list.delete() method, or any wizard for that matter. In addition, the relaxation data loading wizard is destroyed before reinitialising the wizard in the wizard_exec() method.
• Better memory management for the missing data dialog in the GUI analyses. The dialog is now stored as the class variable missing_data, and then is destroyed in the analysis delete() method. Without this, the wxPython dialog would remain in memory for the lifetime of the program.
• Improved memory management for the Sequence and Sequence_2D input GUI elements. These are mainly used in the user function GUI windows. The dialogs are now destroyed before a second is opened.
• Improved memory management for the GUI user function windows. The Destroy() method will now destroy any Sequence or Sequence_2D windows used for the user function arguments.
• The relax prompt window is now being destroyed by the GUI test suite tearDown() method. The window is first closed in the tearDown() method and then destroyed in the clean_up_windows() method.
• Added memory management checking to the GUI test suite tearDown() method. If any top level windows are present, excluding the main GUI window and the relax controller, then a RelaxError will be raised. Such a check will significantly help in future GUI coding, as now there will be feedback if not all windows are properly destroyed.
• Popup menus are now properly destroyed in the GUI tests. In many instances, the wx.Menu.Destroy() method was only being called when the GUI is shown. This causes memory leaking in the GUI tests.
• Changed the title for the user function GUI windows. To better help identify what the window is, the title is now the user function name together with text saying that it is a user function.
• Removed the wx.CallAfter() call in the GUI tests tearDown() method. This was used to call the clean_up_windows() method. However the value of wx.Thread_IsMain() shows that the tearDown() method executes in the main GUI thread. Therefore the wx.CallAfter() call for avoiding racing conditions is not needed.
• Fix for the GUI tests clean_up_windows() tearDown method. After destroying all of the main GUI windows, a wx.Yield() call is made to flush the wxPython event queue. This seems to help with the memory management.
• Temporary disabling of the memory management check in the GUI tests tearDown() method. For some reason, it appears as if it is not possible to destroy wx Windows on MS Windows.
• Created the relax GUI prompt Destroy() method. This is used to cleanly destroy the GUI prompt by first unregistering with the observer objects, destroying then deleting the wx.py.shell.Shell instance, and finally destroying the window.
• Modified the manual_c_module.py developer script so that the path can be supplied on the command line.
• Removed some unused imports, as found by devel_scripts/find_unused_imports.py.
• Added a copyright notice to the memory_leak_test_relax_fit.py development script. This is to know how old the script is, to see how out of date it is in the future.
• Created the memory_leak_test_GUI_uf.py development script. This is to help in tracking down memory leaks in the relax GUI user functions. Instead of using a debugging Python version and guppy (wxPython doesn't seem to work with these), the pympler Python package and its muppy module is used to produce a memory usage printout.
• Clean up of the memory_leak_test_GUI_uf.py development script.
• Created the new devel_scripts/memory_management/ directory. This will be used for holding all of the memory C module leak detection, GUI object leak detection, memory management, etc. development scripts.
• Shifted the memory_leak_test_GUI_uf.py script to devel_scripts/memory_management/GUI_uf_minimise_execute.py.
• Created a base class for the memory management scripts for the GUI user functions. The core of the GUI_uf_minimise_execute.py script has been converted into the GUI_base.py base class module. This will allow for new GUI user function testing scripts to be created.
• Removal of unused imports from the GUI user function memory testing scripts.
• Created a script for testing the memory management when calling the time GUI user function.
• Large memory management improvement for the relax GUI wizards and GUI user functions. The pympler.muppy based memory management scripts in devel_scripts/memory_management for testing the GUI user function windows was showing that for each GUI user function call, 28 wx._core.BoxSizer elements were remaining in memory. This was traced back to the gui.wizards.wiz_objects.Wiz_window class, specifically the self._page_sizers and self._button_sizers lists storing wx.BoxSizer instances. The problem was that 16 page sizers and 16 button sizers were initialised each time for later use, however the add_page() method only added a small subset of these to the self._main_sizer wx.BoxSizer object. But the Destroy() method was only capable of destroying the wx.BoxSizer instances associated with another wxPython object. The fix was to add all page and button sizers to the self._main_sizer object upon initialisation. This will solve many memory issues in the GUI, especially in the GUI tests on Mac OS X systems causing 'memory error' or 'bus error' messages and on MS Windows due to 'USER Object' and 'GDI object' limitations.
• The maximum number of pages in the GUI wizard is no longer hardcoded. The max_pages argument has been added to allow this value to be changed.
• Fix for GUI wizards and GUI user functions. The recent memory management changes caused the wizard windows to have an incorrect layout so that the wizard pages were not visible. Reperforming a layout of the GUI elements did not help. The solution is to not initialise sets of max_pages of wx.BoxSizer elements in the wizard __init__() method, but to generate and append these dynamically via the add_page() method. The change now means that there are no longer multiple unused wx.BoxSizer instances generated for each wizard window created.
• Fix for the GUI wizard _go_next() method. The way to determine if there are no more pages needs to be changed, as there are now no empty list elements at the end of the wizard storage objects.
• Another fix for the now variable sized wizard page list. This time the fix is in the GUI user function __call__() method.
• Created the Relax_fit.test_bug_23244_Iinf_graph system test. This is to catch bug #23244.

Bugfixes

• Bug fix for the structure.align user function. The addition of the molecule name to the displacement ID is now correctly performed.
• Fix for the new Internal_selection.count_atoms() internal structural object selection method. The method was previously returning the total number of molecules, not the total number of atoms in the selection.
• Printout fix for the backend of the structure.translate and structure.rotate user functions. Model numbers of zero were not correctly identified. This also affects the structure.align and structure.superimpose user functions which uses this backend code.
• Another fix for the Internal_selection.count_atoms() internal structural object selection method.
• Small fix for the lib.structure.internal.coordinates.assemble_coord_array() function. The termination condition for determining the residues in common between all structures was incorrect.
• The Structure.test_create_diff_tensor_pdb_oblate system test now uses oblate diffusion relaxation data. This fixes bug #23232, the failure of this system test on Mac OS X. The problem was that the system test was previously using relaxation data for prolate spheroidal diffusion and fitting an oblate tensor to that data. This caused the solution to be slightly different on different CPUs, operating systems, Python versions, etc. and hence the PDB file representation of the diffusion would be slightly different.
• Big bug fix for the GUI tests on MS Windows systems. On MS Windows systems, the GUI tests were unable to complete without crashing. This is because each GUI element requires one 'User object', and MS Windows has a maximum limit of 10,000 of these objects. The GUI tests were taking more than 10,000 and then Windows would say - relax, you die now. The solution is that after each GUI test, all user function windows are destroyed. The user function page is a wx.Panel object, so this requires a Destroy() call. But the window is a Uf_page instance which inherits from Wiz_page which inherits from wx.Dialog. Calling Destroy() on MS Windows and Linux works fine, but is fatal on Mac OS X systems. So the solution is to call Close() instead.
• Fix for the default grid_inc argument for the relaxation curve-fitting auto-analysis. This needs to be an integer.
• Fix for bug #23244. The relaxation curve-fitting auto-analysis now outputs text files and Grace graphs for the I₀ parameter and the I_∞ parameter if it exists.
• Fixes for the package checking unit tests on MS Windows for the target_functions package. The compiled relaxation curve-fitting file is called target_functions\relax_fit.pyd on MS Windows. The package checking was only taking into account *.so compiled files and not *.pyd file.

Links

For reference, the announcement for this release can also be found at following links:

• Official release notes on the relax wiki.
• Gna! news item.
• Gmane mailing list archive.
• The Mail Archive.
• Local archives.
• Mailing list ARChives (MARC).

Softpedia also has information about the newest relax releases:

• Softpedia page for relax on GNU/Linux.
• Softpedia page for relax on MS Windows.
• Softpedia page for relax on Mac OS X.

Announcements

If you would like to receive announcements about new relax versions, please subscribe to the relax announcement mailing list. This list only receives ~10 emails per year. It is archived at the SourceForge archives and in The Mail Archive.

See also

• The relax 3.3 API documentation

• The combined release notes for all relax versions (warning, this is very large).
• The combined release descriptions for all relax versions.
• The combined release metadata for all relax versions.
• The combined release features for all relax versions.
• The combined release changes for all relax versions (warning, this is very large).
• The combined release bugfixes for all relax versions.
• The combined release announcement links for all relax versions.