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.
For the official, easy to navigate release notes, please see
http://wiki.nmr-relax.com/Relax_3.3.6.
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).
The full list of changes is:
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 Dx <= Dy <= Dz.
* More fixes for the
Structure.test_create_diff_tensor_pdb_oblate system test. The initial
Diso value is now set to the real final Diso, 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 (https://gna.org/bugs/?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
(https://gna.org/bugs/?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 (https://gna.org/bugs/?23244). The
relaxation curve-fitting auto-analysis now outputs text files and
Grace graphs for the I0 parameter and the Iinf 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.
relax version 3.3.6.