Welcome to the relax Wiki.

The community-run support site for relax, a program for the study of molecular dynamics using experimental NMR data.

Quick Links

Table of contents	Tutorials	Commands
FAQ	relax releases	All Categories
Read the manual and get help

User contributions - How to edit pages at the wiki

Please read the guidelines here.

What's new?

News & Updates Version 5 of relax. The latest relax release now supports the new versions of wxPython (Phoenix), giving relax a more modern GUI. Migration to SourceForge After the Gna! shutdown at the start of 2017, relax has finally in 2019 been fully migrated to the SourceForge infrastructure. Gna! is permanently shut down! A migration to another open source infrastructure is planned. This will include web hosting for http://www.nmr-relax.com, source code repositories, bug and other trackers, new reports, download pages, and possible a svn to git conversion. Tutorial added Tutorial for sorting data stored as numpy to on-resonance R1rho analysis Version 4 of relax With the latest relax release merging in years of developments in the frame order analysis, the major number has been incremented to relax 4. Tutorial added Tutorial for manual regarding the relaxation dispersion auto-analysis in the GUI Tutorial added Tutorial for R1/R2 Relaxation curve-fitting analysis on varian recorded as fid interleaved Matplotlib example added Matplotlib example Tutorial added Relaxation dispersion analysis R1_rho recorded on varian Tutorial added Relaxation dispersion analysis cpmg fixed time recorded on varian as fid interleaved Tutorial added Adding relaxation dispersion models to relax wiki namespace changed The wiki is now placed at: http://wiki.nmr-relax.com as of 19 of July 2013 GPL License The License has been changed to GPL v3. New Wiki This is the new wiki

Did you know... %PAGE% This is a collection of all of the changes lists for each released relax version. Version 4 of relax relax 4.0 series relax 4.0.3 Addition of the atomic boolean argument to the structure.rmsd user function front end. This will be used to enable the calculation of per-atom RMSDs. Created the Structure.test_rmsd_spins system test for checking the per-atom RMSD calculation. This is for the new option in the structure.rmsd user function. Implemented the per-atom RMSD calculation for the structure.rmsd user function. Fixes for the Relax_fit.test_inversion_recovery system test. The wrong equation was used in the calc.py Python script used to calculate the peak intensities in the test_suite/shared_data/curve_fitting/inversion_recovery/*.list files. The script and Sparky files have been updated. And the I0 value in the script and system test has been changed from 30 to -30, so that the curves start as negative. Huge speed up for the superimposition of a large number of structures. The internal structural object validate_models() method was being called once for each structure via the selection() method prior performing the translations, and once prior to performing the rotations, for creating the atomic selection object. This resulted in the _translate() internal structural object method, which converts all input data to formatted strings, being called hundreds of millions of times. Therefore selection() method no longer calls validate_models(). This may speed up quite a number of internal structure object methods when large numbers of structures are present. Copying deployment script of Ubuntu to a Fedora version. This is a response to bug #25084. Moving fedora to redhat. Google Cloud does not offer fedora images. Adding deploy script for RHEL 6. Added initial script for testing OpenMPI. Making a redhat 6 deploy script, which will upgrade Python from 2.6 to 2.7 The normal installation through yum will have Python 2.6 and only numpy 2.4. This is not good. Moved deploy scripts. There would probably have to be a deploy script for each system. Renamed the Ubuntu deploy script. Adding scripts to test OpenMPI installation and deploy in redhat. Change to pip install command, to source Python first. Adding installation of matplotlib to Redhat 6, Python 2.7. More changing to deploy scripts. Small change to deploy script to build wxPython. More changing to deployment scripts. Moving test script of OpenMPI to bash version. Made a copy of OpenMPI test script for tcsh shell. Again small changes to deployment scripts. Changed more to OpenMPI script. Altering test OpenMPI script to an alias function. Change to bash OpenMPI test script. Last changes to testing of OpenMPI. Small change to test OpenMPI script for bash Back to function in bash script for OpenMPI. Made a deployment script for CentOS 6. Scons on CentOS finds python2.6 instead of python2.7 Try to make the script for tcsh and OpenMPI working on all versions of tcsh. Added the MPI version information to the mpi4py information printout. Windows scons C module compilation now defaults to 32-bit. This is because the default Python downloads are 32-bit. And many libraries (e.g. numpy and scipy) are only pre-compiled as 32-bit. Hence a 64-bit relax build on Windows will require a lot of custom compilation that most users will never do. Added support in the information printout for Windows versions of the file program. This enables the C modules to be identified as 32 or 64-bit, if the file program is installed. relax 4.0.2 Improved formatting for the \yes LaTeX command for the HTML manual. This now inputs the raw HTML character for a tick. The replicate title finding script now processes short titles as well. This shows that the Frame_order.html file will be conflicting and overwritten. Avoidance of a replicated title in the frame order chapter of the manual. Added some unicode characters for improved formatting of the CHANGES file. A number of updates for the release checklist document. This should make it easier to replicate the full release process. Update the release checklist document. The version number at http://wiki.nmr-relax.com/Template:Current_version_relax also needs to be updated for each release. Added a check for the total argument for the frame_order.distribute user function. The maximum value is 9999, as the PDB format cannot accept more models. Creation of the structure.delete_ss user function. This simply resets the helices and sheets data structures in the internal structural object to []. Updated the copyright notices for 2016. Created a short Info_box copyright string for displaying in the main GUI window. This shows the full range of copyright dates. Added the spin_num boolean argument to the structure.load_spins user function. Setting this flag to False will cause the spin number information to be ignored when creating the spin containers. This allows for better support of homologous structures but with different PDB atom numbering. The default flag value is True, preserving the old behaviour. Added support for concatenating atomic positions in the structure.load_spins user function. Together with the spin_num flag set to False, this allows for atomic positions to be read from multiple homologous structures with different PDB atomic numbering. The spin containers will be created from the first structure, in which the spin is defined, and the atomic position from subsequent structures will be appended to the list of current atomic positions. Fix for the Structure.test_read_pdb_internal3 system test. With the new atomic position concatenation support, when called sequentially the structure.load_spins user function should always use the same value for the ave_pos argument. In the GUI the user functions sys_info and time are now grouped into a system subclass. This is to prepare for other system related functions. Added a new 16x16 icon for the oxygen folder-favorites icon. Adding a new file at lib.system. This file will contain different functions related to Python os and system related functions. For example changing directory or printing working directory. In lib.__init__, adding the filename for system.py. Renaming the folder-favorites icon. Deleting the old folder-favorites icon. Adding a new graphics variable: WIZARD_OXYGEN_PATH, to use oxygen icons with size of 200px. Adding the new user function system.cd. This is to change the current working directory. Adding a new 200px of oxygen folder-favorites icon. This is to be used in the wizard image. Adding a user function translation for: This is to catch the new naming of these functions. Adding a new lib.system.pwd() function, to print and return the current working directory. Adding a new user function system.pwd to print/display the current working directory. Adding new 16x16 px and 200px of the oxygen icon folder-development. This icon is used for displaying the current working directory. Adding a relax GUI menu for changing the current working directory. Adding a menu item for changing the current working directory. Adding a verbose True/False for the lib.system.pwd() function. Storing the current working directory as a GUI variable. Adding a toolbar button for changing the current working directory. Adding a verbose flag to lib.system.pwd() function. Changing to a filedialog for the user function system.cd. Adding an observer for current working directory. Modifying the user function system.cd not to show the result to STDOUT. Letting the lib.system.cd function notify the observer, when changing directory. Letting the current working directory be printed in the statusbar in the bottom. Updating self.system_cwd_path when a directory change is observed. For the four auto-analysis methods, the default results directory is now the current working directory instead of the launch directory. Changing the keyboard shortcut for changing the working directory to Ctrl+W. Since Ctrl+C is often used for copying (from the terminal). Fix for GUI prompt bug, where ANSI escape characters should not be printed when interpreter is inherited from wxPython. Added a newline character after printing the script. Optimising the width of the statusbar. When the user function script is called, a notification of pipe_alteration is made. This will force the GUI to update, and make sure that it is up to date. Updated the frame order auto-analysis for the time → system.time user function change. Fix for the GUI status bar element widths. Fixed widths in pixels causes text truncation on many systems, depending on the width of the main relax window. Instead variable widths should be used to allow wxPython to more elegantly present the text while minimising truncation. Created a system test for catching bug #24601, the failure of the optimisation of the R2eff dispersion model when peaks are missing from one spectrum, as reported by Petr Padrta. The test uses his data and script to trigger the bug. Simplified the Relax_disp.test_bug_24601_r2eff_missing_data system test. This is to allow the test to catch bug #24601 to complete in a reasonable time (2 seconds on one system). Fix for the independence of the relax library. As lib.system was using the status object, the library independence was broken. To work around this, the module has simply been shifted into the pipe_control package. Added some missing oxygen icons to allow the relax manual to compile. These are the 128x128 EPS versions of the places/folder-development.png and places/folder-favorites.png Oxygen icons recently introduced. For completeness the 32x32, 48x48, and 128x128 PNG versions of the icons have also been added. To help create these EPS icons in the future, the graphics/README file has been added with a description of the *.eps.gz file creation. Some more details for the *.eps.gz icon creation process. Mac OS X fixes for the Structure.test_pca and Structure.test_pca_observers system tests. The eigenvectors on this OS are sometimes inverted. As the sign of the eigenvector is irrelevant, the vectors hardcoded into the system tests are now inverted as required. relax 4.0.1 Fix for the rigid frame order model 2nd degree frame order matrix in the manual. The wrong symbol was being used. Removed the newparagraph and newsubparagraph definitions from the LaTeX manual. These were causing conflicts with latex2html, preventing the HTML version of the manual from being compiled. These definitions are unnecessary for the current set up of the sectioning in the manual. Modified the short captions in the new frame models chapter of the manual. The runic ᛞ character has been replaced simply by 'Daeg'. This is due to incompatibilities with latex2html which prevents the HTML manual from being compiled. Removal of the definition of a fixed-width table column from the LaTeX manual preamble. This is required as the definition breaks latex2html compatibility, causing a corruption in the figure numbering resulting in the images in the HTML to be essentially randomised. Removal of the accents package to allow the HTML manual to be compiled. The accents LaTeX package is not compatible with latex2html, so the easiest fix is to eliminate the package. Manually rotated the frame order matrix element EPS manual figures, for latex2html compatibility. The '90 rotate' command has been deleted and the bounding box permuted as a b c d → b -c d -a. This allows the angle argument in the \includegraphics{} command to be dropped, as latex2html does not recognise this. It allows the figures to be visible in the HTML version of the manual. Redesign of the frame order parameter nesting table in the manual for latex2html compatibility. The table uses the tikz package, which is fatal for latex2html, even if not used. Therefore the table in the docs/latex/frame_order/parameter_nesting.tex file has been converted into a standalone LaTeX document to create a cropped postscript version of the tikz formatted table. A compilation script has been added as well. The resultant *.ps file is now included into the PCS numerical integration section, rather than this section creating the tikz table. All tikz preamble text has been removed to allow latex2html to run. Workaround for latex2html not being able to handle the allrunes package or associated font. In the preamble htmlonly environment, the frame order symbols are redefined using the text 'Daeg' instead of the runic character ᛞ. Fixes for sub and superscripts throughout the manual. This introduces {} around all sub and superscripted \textrm{} instances. This is not needed for the PDF version of the manual as the missing bracket problem is avoided, but it affects the HTML version of the manual compiled by latex2html, which requires the correct notation. The fixes are for both the new frame order chapter as well as the relaxation dispersion chapter. Editing and fixes for the relax 4.0.0 part of the CHANGES file. Updated and improved the wiki instructions in the relax release checklist document. One more wiki instruction about checking for dead links in the release checklist document. More minor changes to the 'Announcement' section of the release checklist document. Updated the shell script for finding duplicated titles in the LaTeX files of the manual. Converted the duplicate title finding shell script into a Python script. The Python script is far more advanced and uses a different logic to produce a table of replicated titles and their count. The script also returns a failed exit status when replicates exist. Converted the replicated title finding Python script to use a class structure. This allows the script to be imported as a module. The replicate finding has been shifted into a find() class method. Renamed the replicate title finding script. Removed the duplicate LaTeX title finding shell script. This is now handled by the far more advanced Python script. The Scons compilation of the PDF and HTML manuals now checks for replicated titles. A new replicate_title_check target has been added to the scons scripts. This calls the find() method of the replicate LaTeX title finding script to determine if any titles are replicated, and if so the scons target returns with a sys.exit(1) call. This target is set at the start of the user_manual_pdf, user_manual_pdf_nofetch, user_manual_html, user_manual_html_nofetch scons targets. The result is that the manual cannot be compiled if replicate titles exist, forcing the titles to be changed. The result will be that the HTML pages will all be unique, as replicated titles results in only one HTML page being created for all the sections. Elimination of replicated titles in the LaTeX sources that the new frame order chapters introduced. Removal of an old replicated title in the LaTeX sources for the manual. This is the title 'Model-free analysis' which is used for the entire specific analysis chapter as well as for the model-free analysis section of the values, gradients, and Hessians for optimisation chapter. Fixes and improved printouts for the replicate_title_check scons target. Updated all of relax to protect against future changes occurring in the numpy Python package. From numpy version 1.9, the FutureWarning __main__:1: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future. is seen in a large percentage of all relax's user functions. This is caught and turned into a RelaxWarning with the same message. The issue is that the behaviour of the comparison operators == and != will change with future numpy versions. These have been replaced with is and is not throughout the relax code base. Changes have also been made to the minfx and bmrblib packages to match. More future protection against numpy changes. The FutureWarning is `rank` is deprecated; use the `ndim` attribute or function instead. To find the rank of a matrix see `numpy.linalg.matrix_rank`. Therefore the N-state model target function method paramag_info() has been updated to use the .ndim attribute and longer use numpy.rank() function. Created the Mf.test_bug_23933_relax_data_read_ids system test. This is designed to catch bug #23933, the "NameError: global name 'ids' is not defined" problem when loading relaxation data. A truncated version of the PDB file and relaxation data, the full versions of which are attached to the bug report, consisting solely of residues 329, 330, and 331 have been added to the test suite shared data directories, and the system test written to catch the NameError. Updated the Mf.test_bug_23933_relax_data_read_ids system test to catch the RelaxMultiSpinIDError. This allows the system test to pass, as a RelaxMultiSpinIDError is expected. Updated the minfx and bmrblib versions in the release checklist document to 1.0.12 and 1.0.4. This is to remove the numpy FutureWarning messages about the == None and =! None comparisons to numpy data structures, which in the future will change in behaviour. Increased the Gna! news item sectioning depth in the release checklist document. Expanded the description of the sequence.attach_protons user function. This follows from http://thread.gmane.org/gmane.science.nmr.relax.user/1849/focus=1855. Added initial data for testing data from Paul Schanda. This will demonstrate that there are several possibilities to enhance the R2,eff point method. Added the Relax_disp.test_paul_schanda_nov_2015 system test. This will catch the loaning of nan values. Made additional check in sequence reading, that nan values are skipped. Making sure that the replicated 4000 Hz point for the 950 MHz experiment is not overwritten. In the Relax_disp.test_paul_schanda_nov_2015 system test, added a test of counting the R2,eff values. This shows that the replicated R2,eff at 950 MHz/4000 Hz point is overwritten. A solution could be to change the dispersion frequency very little, to allow the addition of the data point. Added further tests to Relax_disp.test_paul_schanda_nov_2015. This will show that replicates of R2,eff values is not handled well. In the function of r2eff_read in data module of the dispersion, added the possibilities to read R2,eff values which are replicated. This is done first checking if the dispersion key exists in the R2,eff dictionary. If it exists, continue add 0.001 to the frequency until a new possibility exists. This should help handle multiple R2,eff points, as separate values and not taking any decision to average them. Added the expectation of raising an relax error, if trying to plot and no model information is stored. Raising an error if plotting dispersion curves, and no model is saved. Changed example script for analysing data. Extended the Relax_disp.test_paul_schanda_nov_2015 system test to include auto-analysis and clustered fits. This should show that the analysis is now possible. Added a temporary state and a script for GUI setup to the data Paul Schanda. Added the Relax_disp.test_paul_schanda_nov_2015 GUI test. This will show that loading a state will create a problem. Traceback (most recent call last): TypeError: int() argument must be a string or a number, not 'NoneType'. Added a sample script for back-calculating relaxation data from a model-free results file. This is useful when the results file is not the final model, as these results file do not contain the back-calculated data. This is in response to Christina Möller's support request #3303. Using Gary's lib.float.isNaN() instead of math.isnan(), to have backwards compatibility with python 2.5. Fix for spelling mistake and documenting the new behavior of relax_disp.r2eff_read, when reading R2,eff points with the same frequency. If the spin-container already contain R2,eff values with the 'frequency of the CPMG pulse' or 'spin-lock field strength', the frequency will be changed by a infinitesimal small value of + 0.001 Hz. This allow for duplicates or more of the same frequency. Modified the internal structural object to be less influenced by the format of the PDB. The PDB serial number is now intelligently handled, in that it is reset to 1 when a new model is created. This information is still kept for supporting the logic of the reading of the CONECT records, and will be eliminated in the future. The chain ID information is now no longer stored in the internal structural object, as this information is recreated by the structure.write_pdb user function based on how the internal structural object has been created. Updates to the Noe and Structure system test classes for the internal structural object changes. The serial number can now be reset, and the chain ID information is no longer stored. Added a file to the test suite shared data to help implement the PCA structural analysis. This is the N-domain of the CaM-IQ complex used in a frame order analysis. It is the first 5 structures from a call to the frame_order.distribute user function, with the different rigid-bodies merged back together into a single molecule. Created the structure.pca user function front end. This is currently modelled on the structure.rmsd user function framework. Basic implementation of the structure.pca user function back end. This is the new pca() function of the pipe_control.structure.main module. It simply performs some checks, assembles the atomic coordinates, and the passes control to the relax library pca_analysis() function of the currently unimplemented lib.structure.pca module. Partial implemented of the PCA analysis in the relax library. This is for the new structure.pca user function. The lib.structure.pca module has been created, and the pca_analysis() function created to calculate the structure covariance matrix, via the calc_covariance_matrix() function, and then calculate the eigenvalues and eigenvectors of the covariance matrix, sorting them and truncating to the desired number of PCA modes. Added the algorithm and num_modes arguments to the structure.pca user function. These are passed all the way into the relax library backend. Implemented the SVD algorithm for the PCA analysis in the relax library. This simply calls numpy.linalg.svd(). The PCA analysis in the relax library now calculates the per structure projections along the PCs. The PCA analysis function in the relax library is now returning data. This includes the PCA values and vectors, and the per structure projections. The PCA values and vectors, and the per structure projections are now being stored. This is in the structure.pca user function backend in the pipe_control.structure.main module. Added the format and dir arguments to the structure.pca user function. This is to the front and back ends. Modified the assemble_structural_coordinates() method to return more information. This is from the pipe_control.structure.main module. The lists boolean argument is now accepted which will cause the function to additionally return the object ID list per molecule, the model number list per molecule, and the molecule name list per molecule. The structure.pca user function now creates graphs of the PC projections. This includes PC1 vs. PC2, PC2 vs. PC3, etc. Added the Gromacs PCA results for the distribution.pdb file. This includes a script used to execute all parts of Gromacs and all output files. Updated the Gromacs PCA results for the newest 5.1.1 Gromacs version. Created an initial Structure.test_pca system test. This executes the new structure.pca user function, and checks if data is stored in cdp.structure. Improved the graphs in the backend of the structure.pca user function. The graphs are now clustered so that different models of the same structure in the same data pipe are within one graph set. The graph header has also been improved. Expanded the Structure.test_pca system test checks to compare to the values from Gromacs. A weighted mean structure can now be calculated. This is for the calc_mean_structure() function of the relax library module lib.structure.statistics. Weights can now be supplied for each structure to allow for a weighted mean to be calculated and returned. Added support for observer structures in the structure.pca user function. This allows a subset of the structures used in the PC analysis to have zero weight so that these structures can be used for comparison purposes. The obs_pipes, obs_models, and obs_molecules arguments have been added to the user function front end. The backend uses this to create an array of weights for each structure. And the lib.structure.pca functions use the zero weights to remove the observer structures from the PC mode calculations. Created the Structure.test_pca_observers system test. This is for testing the new observer structures concept of the structure.pca user function. Improved the printouts from the relax library principle component analysis. This is in the pca_analysis() function of the lib.structure.pca module. Fixes and improvements for the graphs produced by the structure.pca user function. The different sets are now correctly created, and are now labelled in the plots. Adding a testing deploy script, for rapid deployment on Google Cloud Computing. This is for an intended install in Ubuntu 14.04 LTS. Expanding script for installation. Putting installation into functions in deploy script. Splitting deploy script into several small functions. Adding checking statements to install script. When sourcing the scripts, several functions can be performed instead. Added spaces to install script for better printing. Adding a tutorial script. Adding 2 tutorial scripts. Fix for small spin ID error in tutorial script. Created a system test for catching bug #24131, the BMRB export failure when the SpinContainer object has no S2 attribute, as reported by Martin Ballaschk. Modified the Mf.test_bug_24131_bmrb_deposition system test to check for the RelaxError. The test results in a RelaxError, as the results file contains no selected spins. Added the Mf.test_bug_24131_missing_interaction system test to catch another problem. This is part of bug #24131, the BMRB export failure with the SpinContainer object having no S2 value. However the previous fix of skipping deselected spins introduced a new problem of relax still searching for the interatomic interactions for that deselected spin. relax 4.0.0 Deletion of the frame_order.average_position user function and all of the associated backend code. This user function allowed the user to specify five different types of displacement to the average moving domain position: a pure rotation, with no translation, about the pivot of the motion in the system; a rotation about the pivot of the motion of the system together with a translation; a pure translation with no rotation; a rotation about the centre of mass of the moving domain with no translation; a rotation about the centre of mass of the moving domain together with a translation. Now the last option will be the default and only option. This option is equivalent to the standard superimposition algorithm (the Kabsch algorithm) to a hypothetical structure at the real average position. The other four are due to the history of the development of the theory. These limit the usefulness of the theory and will only cause confusion. Clean up of the frame order target function code. This matches the previous change of the deletion of the frame_order.average_position user function. The changes include the removal of the translation optimisation flag as this is now always performed, and the removal of the flag which causes the average domain rotation pivot point to match the motional pivot point as these are now permanently decoupled. Alphabetical ordering of functions in the lib.frame_order.pseudo_ellipse module. Eliminated all of the 'line' frame order models, as they are not implemented yet. This is just frontend code - the backend does not exist. Updated the isotropic cone CaM frame order test model optimisation script. Due to all of the changes in the frame order analysis, the old script was no longer functional. Created a script for the CaM frame order test models for finding the average domain position. As the rotation about a fixed pivot has been eliminated, the shift from 1J7P_1st_NH_rot.pdb to 1J7P_1st_NH.pdb has to be converted into a translation and rotation about the CoM. This script will be used to replace the pivot rotation Euler angles with the translation vector and CoM rotation Euler angles. However the structure.superimpose user function will need to be modified to handle both the standard centroid superimposition as well as a CoM superimposition. Updated the CaM frame order test model superimposition script. The structure.superimpose user function is now correctly called. The output log file has been added to the repository as it contains the correct translation and Euler rotation information needed for the test models. Parameter update for the isotropic cone CaM frame order test model optimisation script. The Euler angles for the rotation about the motional pivot have been replaced by the translation vector and Euler angle CoM rotation parameters. Fix for a number of the frame order models which do not have parameter constraints. The linear_constraint() function was returning A, b = [], [] for these models, but these empty numpy arrays were causing the minfx library to fail. These values are now caught and the constraint algorithm turned off in the minimise() specific API method. Increased the precision of all the data in the CaM frame order test data generation base script. These have all been converted from float16 to float64 numpy types. Fix for the RDC error setting in the CaM frame order test data generation base script. The rdc_err data structure is located in the interatomic data containers, no the spin containers. Modification of the structure loading part of the CaM frame order data generation base script. The structures are now only loaded if the DIST_PDB flag is set, as they are only used for generating the 3D distribution of structures. This saves a lot of time and computer memory. Huge speedup of the CaM frame order test data generation base script. By using multidimensional numpy arrays to store the atomic positions and XH unit vectors of all spins, and performing the rotations on these structures using numpy.tensordot(), the calculations are now a factor of 10 times faster. The progress meter had to be changed to show every 1000 rather than 100 iterations. The rotations of the positions and vectors are now performed sequentially, accidentally fixing a bug with the double motion models (i.e. the 'double rotor' model). Modified the CaM frame order test data generation base script to conserve computer RAM. The XH vector and atomic position data structures for all N rotations are now of the numpy.float32 rather than numpy.float64 type. The main change is to calculate the averaged RDCs and averaged PCSs separately, deleting the N-sized data structures once the data files are written. Complete redesign of the CaM frame order data generation base script for speed and memory savings. Although the rotated XH bond vector and atomic position code was very fast, the amount of memory needed to store these in the spin containers and interatomic data containers was huge when N > 1e6. The subsequent rdc.back_calc and pcs.back_calc user function calls would also take far too long. Therefore the base script has been redesigned. The _create_distribution() method has been split into four: _calculate_pcs(), _calculate_rdc(), _create_distribution(), and _pipe_setup(). The _pipe_setup() method is called first to set up the data pipe with all required data. Then the _calculate_rdc() and _calculate_pcs() methods, and finally _create_distribution() if the DIST_PDB flag is set. The calls to the rdc.back_calc and pcs.back_calc user functions have been eliminated. Instead the _calculate_rdc() and _calculate_pcs() methods calculate the averaged RDC and PCS themselves as numpy array structures. Rather than storing the huge rotated vectors and atomic positions data structures, the RDCs and PCSs are summed. These are then divided by self.N at the end to average the values. Compared to the old code, when N is set to 20 million the RAM usage drops from ~20 GB to ~65 MB. The total run time is also decreased on one system from a few days to a few hours (an order or two of magnitude). Changed the progress meter updating for the CaM frame order test data generation base script. The spinner was far too fast, updating every 5 increments, and is now updated every 250. And the total number is now only printed every 10,000 increments. Improvements to the progress meter for the CaM frame order test data generation base script. Commas are now printed between the thousands and the numbers are now right justified. Large increase in accuracy of the RDC and PCS averaging. This is for the CaM frame order test data generation base script. By summing the RDCs and PCSs into 1D numpy.float128 arrays (for this, a 64-bit system is required), and then dividing by N at the end, the average value can be calculated with a much higher accuracy. As N becomes larger, the numerical averaging introduces greater and greater amounts of truncation artifacts. So this change alleviates this. Fix for the RDC and PCS averaging in the CaM frame order test data generation base script. For the double rotor model, or any multiple motional mode model, the averaging was incorrect. Instead of dividing by N, the values should be divided by NM, where M is the number of motional modes. Huge increase in precision for the CaM frame order free rotor model test data. The higher precision is because the number structures in the distribution is now twenty million rather than one million, and the much higher precision numpy.float128 averaging of the updated data generation base script has been used. This data should allow for a much better estimate of the β and γ average domain position parameter values for the free rotor models which are affected by the collapse of the α parameter to zero. Huge increase in precision for the CaM frame order double rotor model test data. The higher precision is because the number structures in the distribution is now over twenty million (45002) rather than a quarter of a million (5002). And the much higher precision numpy.float128 averaging of the updated data generation base script has been used. Fix for the constraint deactivation in the frame order minimisation when no constraints are present. Huge increase in precision for the CaM frame order rotor model test data. The higher precision is because the number structures in the distribution is now 20 million rather than 166,666, and the numpy.float128 data averaging has been used. Large increase in precision for the 2nd CaM frame order rotor model test data set. The higher precision is because the number structures in the distribution is now 20 million rather than 1,000,001 and the numpy.float128 data averaging has been used. Parameter update for the 2nd rotor CaM frame order test model optimisation script. The Euler angles for the rotation about the motional pivot have been replaced by the translation vector and Euler angle CoM rotation parameters. Large increase in precision for the 2nd CaM frame order free rotor model test data set. The higher precision is because the number structures in the distribution is now 20 million rather than 999,999 and the numpy.float128 data averaging has been used. Updated the CaM frame order test model superimposition script. The Ca2+ atoms are now deleted from the structures before superimposition so that the centroid matches that used in the frame order analysis. The average domain rotation centroid is printed out when setting up the frame order target functions. This is to help the user understand what is happening in the analysis. Faster clearing of numpy arrays in the lib.frame_order modules. The x[:] = 0.0 notation is now used to set all elements to zero, rather than nested looping over all dimensions. This however has a negligible effect on the test suite timings. Large increase in precision for the CaM frame order pseudo-ellipse model test data set. The higher precision is because the number structures in the distribution is now 20 million rather than 1 million and the numpy.float128 data averaging has been used. Improved the value setting in the optimisation() method of the CaM frame order system tests. This is in the base script used by all scripts in test_suite/system_tests/scripts/frame_order/cam/. Changed the average domain position parameter values in the CaM frame order system tests. This is in the base script used by all scripts in test_suite/system_tests/scripts/frame_order/cam/. The translation vector coordinates are now set, as well as the CoM Euler angle rotations. These come from the log file of the test_suite/shared_data/frame_order/cam/superimpose.py script, and are needed due to the simplification of the average domain position mechanics now mimicking the Kabsch superimposition algorithm. The CaM frame order system test mesg_opt_debug() method now prints out the translation vector. This is printed out at the end of all CaM frame order system tests to help with debugging when the test fails. Change for how the CaM frame order system test scripts handle the average domain position rotation. The trick of pre-rotating the 3D coordinates was used to solve the {α, β, γ} -> {0, β', γ'} angle conversion problem in the rotor models no longer works now that the average domain position mechanics has been simplified. Instead, high precision optimised β' and γ' values are now set, and the ave_pos_alpha value set to None. The high precision parameters were obtained with the frame_order.py script located in the directory test_suite/shared_data/frame_order/cam/free_rotor. The free rotor target function was modified so that the translation vector is hard-coded to [-20.859750185691549, -2.450606987447843, -2.191854570352916] and the axis θ and φ angles to 0.96007997859534299767 and 4.0322755062196229403. These parameters were then commented out for the model in the module specific_analyses.frame_order.parameters so only β' and γ' were optimised. Iterative optimisation was used with increasing precision, ending up with high precision using 10,000 Sobol' points. Updated a number of the CaM frame order system tests for the higher precision data. The new data results in chi-squared values at the real solution to be much closer to zero. Change for how the CaM frame order free-rotor pseudo-ellipse test script handle the average position. Added FIXME comments to the 2nd free-rotor CaM frame order model system test scripts. These explain the steps required to obtain the correct β' and γ' average domain position rotation angles. Large increase in precision for the CaM frame order isotropic cone model test data set. The higher precision is because the number structures in the distribution is now 20 million rather than 1 million and the numpy.float128 data averaging has been used. Large increase in precision for the CaM frame order free-rotor, isotropic cone model test data set. The higher precision is because the number structures in the distribution is now 20 million rather than 1 million and the numpy.float128 data averaging has been used. Updated the CaM frame order free-rotor model test data set for testing for missing data. This is the data in test_suite/shared_data/frame_order/cam/free_rotor_missing_data. To simplify the copying of data from test_suite/shared_data/frame_order/cam/free_rotor and then the deletion of data, the missing.py script was created to automate the process. The generate_distribution.py script and some of the files it creates were removed from the repository so it is clearer how the data has been created. Large increase in precision for the 2nd CaM frame order free-rotor, isotropic cone model test data set. The higher precision is because the number structures in the distribution is now 20 million rather than 1 million and the numpy.float128 data averaging has been used. Large increase in precision for the CaM frame order free-rotor, pseudo-ellipse model test data set. The higher precision is because the number structures in the distribution is now 20 million rather than 1 million and the numpy.float128 data averaging has been used. Large increase in precision for the CaM frame order pseudo-ellipse model test data set. The higher precision is because the number structures in the distribution is now 20 million rather than 1 million and the numpy.float128 data averaging has been used. Updated a number of the CaM frame order system tests for the higher precision data. The new data results in chi-squared values at the real solution to be much closer to zero. The free-rotor pseudo-ellipse models might need investigation however as the chi-squared values have increased. Elimination of the error_flag variable from the frame order analysis. This flag is used to activate some old code paths which have now been deleted as they are never used. Optimisation of the average domain position for the CaM frame order free-rotor models. The log file that shows the optimisation of the average domain position for the free-rotor models has been added to the repository for reference. This is for the simple free-rotor model, but the optimised position holds for the isotropic cone and pseudo-ellipse model data too. To perform the optimisation, the axis_theta and axis_phi parameters were removed from the model and hardcoded into the target function. As the rotor axis is know, this allows the average domain position to be optimised in isolation. Visual inspection of the results confirmed the position to be correct. Fixes for the 2nd frame order free-rotor system tests. The average domain position parameters are now set to the correct values, matching those in the relax log file frame_order_ave_pos_opt.log in test_suite/shared_data/frame_order/cam/free_rotor2. Updated the 2nd CaM free-rotor frame order system tests for the correct average domain position. The chi-squared values are now significantly lower. Increased the precision of the chi-squared value testing in the CaM frame order system tests. The check_chi2 method has been modified so that the chi-squared value is no longer scaled, and the precision has been increased from 1 significant figure to 4. All of the tests have been updated to match. The minimisation verbosity flag now effects the frame order RelaxWarning about turning constraints off. Preformed a frame order analysis on the 2nd CaM free-rotor model test data. This is to check that everything is operating as expected. Small speedup for the frame order target functions for most models. The rotation matrix corresponding to each Sobol' point for the numerical integration is now pre-calculated during target function initialisation rather than once for each function call. Updates for some of the frame order system tests for the rotation matrix pre-calculation change. As the rotation matrix is being pre-calculated, one consequence is that the Sobol' angles are now full 64-bit precision rather than 32-bit. Therefore this changes the chi-squared value a little, requiring updates to the tests. Preformed a frame order analysis on the CaM free-rotor mode test data set. This is to demonstrate that everything is operating correctly. Preformed a frame order analysis on the CaM free-rotor mode test data set with missing data. This is to demonstrate that everything is operating correctly. Attempt to speed up the pseudo-elliptic frame order models. The quasi-random numerical integration of the PCS for the pseudo-ellipse has been modified so that the torsion angle check for each Sobol' point is preformed before the tmax_pseudo_ellipse() function call. A new check that the tilt angle is less than cone_theta_y, the larger of the two cone angles, has also been added to avoid tmax_pseudo_ellipse() when the θ tilt angle is outside of an isotropic cone defined by cone_theta_y. Preformed a frame order analysis on a number of the CaM test data sets. This includes the rotor, isotropic cone, and pseudo-ellipse, and the analyses demonstrate a common bug between all these models. Preformed a frame order analysis on the rigid CaM test data set. This is to demonstrate that everything is operating correctly. Optimisation of the rotor model to the rigid CaM frame order test data. The optimisation script and all results files have been added to the repository. Increased the grid search bounds for the frame order average domain translation. Instead of being a 10 Angstrom box centred at {0, 0, 0}, now the translation search has been increased to a 100 Angstrom box. Proper edge case handling and slight speedup of the frame order PCS integration functions. The case whereby no Sobol' points in the numerical integration lie within the motional distribution is now caught and the rotation matrix set to the motional eigenframe to simulate the rigid state. As the code for averaging the PCS was changed, it was also simplified by removing an unnecessary loop over all spins. This should speed up the PCS integration by a tiny amount. Created a new CaM frame order test data set. This is for the rotor model with a very small torsion angle of 1 degree, and will be used as a comparison to the rigid model and for testing the performance of the rotor model for an edge case. Updated the frame order representations in all of the frame_order.py scripts for the CaM test data. All PDB files are now gzipped to save space, the old pymol.cone_pdb user function calls replaced with pymol.frame_order, and an average domain PDB file for the exact solution is now created in all cases. The minimisation constraints are now turned on for all CaM test data frame_order.py optimisation scripts. Updated the rotor CaM test data frame_order.py script for the parameter reduction. The rotor axis {θ, φ} polar angles have been replaced by the single axis α angle. This now matches the script for the 2nd rotor model. Updated the parameters in all of the frame_order.py scripts for the CaM test data. The parameters are now specified at the top of the script as variables. All scripts now handle the change to the translation + CoM rotation for the average domain position rather than having a pure rotation about a fixed pivot, which is no longer supported. The frame_order.num_int_pts user function now throws a RelaxWarning if not enough points are used. Changed the creation of Sobol' points for numerical integration in the frame order target functions. The points are now all created at once using the i4_sobol_generate() rather than i4_sobol() function from the extern.sobol.sobol_lib module. Increased the number of integration points from 50 or 100 to 5000. This is for all CaM frame_order.py test data optimisation scripts. The higher number of points are essential for optimising the frame order models and hence for checking the relax implementation. Updated the frame_order.py optimisation script for the small angle CaM rotor frame order test data. This now has the correct rotor torsion angle of 1 degree, and the spherical coordinates are now converted to the axis α parameter. Expanded the capabilities of the pymol.frame_order user function. The isotropic and pseudo-elliptic cones are now represented as they used to be under the pymol.cone_pdb user function. To avoid code duplication, the new represent_cone_axis(), represent_cone_object() and represent_rotor_object() functions have been created to send the commands into PyMOL. Increased the precision of all of the CaM frame order system tests by 40 times. The number of Sobol' integration points have been significantly increased while only increasing the frame order system test timings by ~10%. This allows for checking for chi-squared values at the minima much closer to zero, and is much better for demonstrating bugs. Optimisation constraints are no longer turned off in the frame order auto-analysis. Constraints are now supported by all frame order models, or automatically turned off for those which do not have parameter constraints. Fix for the frame order visualisation script created by the auto-analysis. The call to pymol.frame_order is now correct for the current version of this user function. Removed a terrible hack for handling the frame order analysis without constraints. This is no longer needed as the log-barrier method is now used to constrain the optimisation, so that the torsion angle can no longer be negative. Constraints are now implemented in the frame order grid search. This is useful for the pseudo-elliptic models as the cone θx < θy constraint halves the optimisation space. Expanded the CaM rotor test data frame_order.py optimisation script. The optimisation is now implemented as in the auto-analysis, with an iterative increase in accuracy of the quasi-random numerical integration together with an decrease of the function tolerance cutoff for optimisation. The accuracy of the initial chi-squared calculation is now much higher. And the accuracy of the initial grid search and the Monte Carlo simulations is now much lower. The results of the new optimisation are included. Expanded the CaM pseudo-ellipse test data frame_order.py optimisation script. The optimisation is now implemented as in the auto-analysis, with an iterative increase in accuracy of the quasi-random numerical integration together with an decrease of the function tolerance cutoff for optimisation. The accuracy of the initial chi-squared calculation is now much higher. And the accuracy of the initial grid search and the Monte Carlo simulations is now much lower. The results of the new optimisation are included. Added one more iteration for the zooming optimisation of the frame order auto-analysis. This is to improve the speed of optimisation when all RDC and PCS data is being used. The previous iterations where with [100, 1000, 200000] Sobol' integration points and [1e-2, 1e-3, 1e-4] function tolerances. This has been increased to [100, 1000, 10000, 100000] and [1e-2, 1e-3, 5e-3, 1e-4]. The final number of points has been decreased as that level of accuracy does not appear to be necessary. These are also only default values that the user can change for themselves. Updated the CaM frame order data generation base script to print out more information. This is for the first axis system so that the same amount of information as the second system is printed. Expanded the CaM isotropic cone test data frame_order.py optimisation script and added the results. The optimisation is now implemented as in the auto-analysis, with an iterative increase in accuracy of the quasi-random numerical integration together with an decrease of the function tolerance cutoff for optimisation. The accuracy of the initial chi-squared calculation is now much higher. And the accuracy of the initial grid search and the Monte Carlo simulations is now much lower. Important fix for the 2nd rotor model of the CaM frame order test data. The tilt angle was not set, and therefore the old data matched the non-tilted 1st rotor model. All PCS and RDC data has been regenerated to the highest quality using 20,000,000 structures. Updated the 3 Frame_order.test_cam_rotor2* system tests for the higher quality data. Expanded the 2nd CaM pseudo-ellipse test data frame_order.py optimisation script. The optimisation is now implemented as in the auto-analysis, with an iterative increase in accuracy of the quasi-random numerical integration together with an decrease of the function tolerance cutoff for optimisation. The accuracy of the initial chi-squared calculation is now much higher. And the accuracy of the initial grid search and the Monte Carlo simulations is now much lower. The results of the new optimisation have been added to the repository. Expanded the CaM free-rotor isotropic cone test data frame_order.py optimisation script. The optimisation is now implemented as in the auto-analysis, with an iterative increase in accuracy of the quasi-random numerical integration together with an decrease of the function tolerance cutoff for optimisation. The accuracy of the initial chi-squared calculation is now much higher. And the accuracy of the initial grid search and the Monte Carlo simulations is now much lower. The results of the new optimisation have been added to the repository. Expanded all remaining CaM test data frame_order.py optimisation scripts. The optimisation is now implemented as in the auto-analysis, with an iterative increase in accuracy of the quasi-random numerical integration together with an decrease of the function tolerance cutoff for optimisation. The accuracy of the initial chi-squared calculation is now much higher. And the accuracy of the initial grid search and the Monte Carlo simulations is now much lower. Updated the CaM 2-site to rotor model frame_order.py optimisation script for the parameter reduction. The rotor frame order model axis spherical angles have now been converted to a single α angle. Fix for a number of the frame order models which do not have parameter constraints. This change to the grid_search() API method is similar to the previous fix for the minimise() method. The linear_constraint() function was returning A, b = [], [] for these models, but these empty numpy arrays were causing the dot product with A to fail in the grid_search() API method. These values are now caught and the constraint algorithm turned off. Converted the 'free rotor' frame order model to the new axis_alpha parameter system. The axis_theta and axis_phi spherical coordinates are converted to the new reduced parameter set defined by a random point in space (the CoM of all atoms), the pivot point, and a single angle α. The α parameter defines the rotor axis angle from the xy-plane. Parameter conversion for all of the CaM free rotor test data frame_order.py optimisation scripts. The rotor axis spherical angles have been replaced by the axis α angle defining the rotor with respect to the xy-plane. Modified the CaM frame order base system test script to catch a bug in the free rotor model. The axis spherical angles are no longer set for the rotor or free rotor models, as they use the α angle instead and the lack of the θ and φ parameters triggers the bug. The PDB representation of the frame order motions is also now tested for all frame order models, as it was turned off for the rigid, rotor and free rotor models and this is where the bug lies. Fix for the failure of the frame_order.pdb_model user function for the free rotor frame order model. This is due to the recent parameter conversion to the axis α angle. Eliminated the average position α Euler angle parameter from the free-rotor pseudo-ellipse model. As this frame order model is a free-rotor, the average domain position is therefore undefined and it can freely rotate about the rotor axis. One of the Euler angles for rotating to the average position can therefore be removed, just as in the free rotor and free rotor isotropic cone models. Eliminated the ave_pos_alpha parameter from the free rotor psuedo-ellipse model target function. The average domain position α Euler angle has already been removed from the specific analyses code and this change brings the target function into line with these changes. Added the full optimisation results for the 2nd rotor frame order model for the CaM test data. This is from the new frame_order.py optimisation script and the results demonstrate the stability of the rotor model. Added the full optimisation results for the small angle rotor CaM frame order test data. This is from the new frame_order.py optimisation script and the results demonstrate the stability of the rotor model, even when the rotor is as small as 1 degree. Fix for the free rotor PDB representation created by the frame_order.pdb_model user function. The simulation axes were being incorrectly generated from the θ and φ angles, which no longer exist as they have been replaced by the α angle. Added the full optimisation results for the free rotor pseudo-ellipse frame order model. This is for the CaM test data using the new frame_order.py optimisation script. Added the full optimisation results for the rotor frame order model. This is for the 2-site CaM test data using the new frame_order.py optimisation script. The CaM frame order data generation base script now uses lib.compat.norm(). This is to allow the test suite to pass on systems with old numpy versions whereby the numpy.linalg.norm() function does not support the new axis argument. Modified the pymol.cone_pdb and pymol.frame_order user functions to use PyMOL IDs. The PyMOL IDs are used to select individual objects in PyMOL rather than all objects so that the subsequent PyMOL commands will only be applied to that object. This allows for multiple objects to be handled simultaneously. Added the full optimisation results for the free rotor frame order model. This is for the CaM test data using the new frame_order.py optimisation script. Added the full optimisation results for the 2nd free rotor frame order model. This is for the CaM test data using the new frame_order.py optimisation script. Added the full optimisation results for the free rotor frame order model with missing data. This is for the CaM test data using the new frame_order.py optimisation script. Added a script for recreating the frame order PDB representation and displaying it in PyMOL. This is for the optimised results. Fixes for the rotor object created by the frame_order.pdb_model user function. The rotor is now also shown for the free rotor pseudo-ellipse, despite it being a useless model, and the propeller blades are no longer staggered for all the free rotor models so that two circles are no longer produced. Updated the free rotor and 2nd free rotor PDB representations using the represent_frame_order.py script. This is for the CaM frame order test data. Reparameterisation of the double rotor frame order model. The two axes defined by spherical angles have been replaced by a full eigenframe and the second pivot has been replaced by a single displacement along the z-axis of the eigenframe. Removed the 2nd pivot point infrastructure from the frame order analysis. The 2nd pivot is now defined via the pivot_disp parameter. Added the 2nd rotor axis torsion angle to the list of frame order parameters. This is for the double rotor model. Comment fixes for the eigenframe reconstruction in the frame order target functions. Converted the double rotor frame order model target function to use the new parameterisation. Fix for the PDB representation generated by frame_order.pdb_model for the free rotor pseudo-ellipse. Fix for the Frame_order.test_rigid_data_to_free_rotor_model system test. As the free rotor has undergone a reparameterisation, the chi-squared value is now higher. The value is reasonable as the free rotor can never model the rigid system. Removed the structure loading and transformation from the CaM frame order system tests. This was mimicking the old behaviour of the auto-analysis. However as that behaviour has been shifted into the backend of the frame_order.pdb_model user function, which is called by these system tests as well, the code is now redundant and is wasting test suite time. Removed the setting of the second pivot point in the CaM frame order system tests. The second pivot point has been removed from the double rotor frame order model to eliminate parameter redundancy, so no models now have a conventional second pivot. Modified the CaM frame order system test base script to test alternative code paths. This pivot point was fixed in all tests, so the code in the target functions behind the pivot_opt flag was not being tested. Now for those system tests whereby the calc rather than minimise user function is called, the pivot is no longer fixed to execute this code. Simplification and clean up of the RDC and PCS flags in the frame order target functions. The per-alignment flags have been removed and replaced by a global flag for all data. This accidentally fixes a bug when only RDCs are present, as the calc_vectors() method was being called when it should not have been. Speedup and simplifications for the vector calculations used for the PCS numerical integration. This has a minimal effect on the total speed as the target function calc_vectors() method is not the major bottleneck - the slowest part is the quasi-random numerical integration. However the changes may be useful for speeding up the integration later on. The 3D pivot point, average domain rotation pivot, and paramagnetic centre position arrays are now converted into rank-2 arrays in __init__() where the first dimension corresponds to the spin. Each element is a copy of the 3D array. These are then used for the calculation of the pivot to atom vectors, eliminating the looping over spins. The numpy add() and subtract() ufuncs are used together with the out argument for speed and to avoid temporary data structure creation and deletion. The end result is that the calculated vector structure is transposed, so the first dimension are the spins. The changes required minor updates to a number of system tests. The target functions themselves had to be modified so that the pivot is converted to the larger structure when optimised, or aliased. Added a script for timing different ways to calculate PCSs and RDCs for multiple vectors. This uses the timeit module rather than profile to demonstrate the speed of 7 different ways to calculate the RDCs or PCSs for an array of vectors using numpy. In the frame order analysis, this is the bottleneck for the quasi-random numerical integration of the PCS. The log file shows a potential 1 order of magnitude speedup between the 1st technique, which is currently used in the frame order analysis, and the 7th and last technique. The first technique loops over each vector, calculating the PCS. The last expands the PCS/RDC equation of the projection of the vector into the alignment tensor, and calculates all PCSs simultaneously. Added another timing script for RDC and PCS calculation timings. This time, the calculation for multiple alignments is now being timed. An addition set of methods for calculating the values via tensor projections have been added. For 5 alignments and 200 vectors, this demonstrates a potential 20x speedup for this part of the RDC/PCS calculation. Most of this speedup should be obtainable for the numerical PCS integration in the frame order models. Small speedup for all of the frame order models. The PCS averaging in the quasi-random numerical integration functions now uses the multiply() and divide() numpy methods to eliminate a loop over the alignments. For this, a new dimension over the spins was added to the PCS constant calculated in the target function __init__() method. In one test of the pseudo-ellipse, the time dropped from 191 seconds to 172. Added another timing script for helping with speeding up the frame order analysis. This is for the part where the rotation matrix for each Sobol' integration point is shifted into the eigenframe. Python 3 fix for the CaM frame order system test base script. Added the full optimisation results for the torsionless isotropic cone frame order model. This is for the CaM test data using the new frame_order.py optimisation script. Small speedups for all of the frame order models in the quasi-random numerical PCS integration. These changes result in an ~10% speedup. Testing via the func_pseudo_ellipse() target function using the relax profiling flag, the time for one optimisation decreased from 158 to 146 seconds. The changes consist of pre-calculating all rotations of the rotation matrix into the motional eigenframe in one mathematical operation rather than one operation per Sobol' point rotation, unpacking the Sobol' points into the respective angles prior to looping over the points, and taking the absolute value of the torsion angle and testing if it is out of the bounds rather than checking both the negative and positive values. Attempt at speeding up the torsionless pseudo-ellipse frame order model. The check if the Sobol' point is outside of an isotropic cone defined by the largest angle θy is now performed to avoid many unnecessary calls to the tmax_pseudo_ellipse() function. This however reveals a problem with the test suite data for this model. Updated all of the CaM frame order system tests for the recent speedup. The speedup switched to the use of numpy.tensordot() for shifting each Sobol' rotation into the eigenframe rather than the previous numpy.dot(). Strangely this affects the precision and hence the chi-squared value calculated for each system test - both increasing and decreasing it randomly. The frame order target function calc_vectors() method arguments have all been converted to keywords. This is in preparation for handling a second pivot argument for the double rotor model. Updated the double rotor frame order model to be in a pseudo-functional state. Bugs in the target function method have been removed, the calc_vectors() target function method now accepts the pivot2 argument (but does nothing with it yet), and the lib.frame_order.double_rotor module has been updated to match the logic used in all other lib.frame_order modules. The frame_order.pdb_model user function no longer tries to create a cone object for the double rotor. Added a timeit script and log file for different ways of checking a binary numpy array. Modified the rigid_test.py system test script to really be the rigid case. This is used in all of the Frame_order.test_rigid_data_to_*_model system tests. Previously the parameters of the dynamics were set to being close to zero, to catch the cases were a few Sobol' PCS integration points were accepted. But now the case were no Sobol' points can be used is being tested. This checks a code path currently untested in the test suite, demonstrating many failures. Fix for the frame order matrix calculation for a pseudo-elliptic cone with angles of zero degrees. The lib.frame_order.pseudo_ellipse_torsionless.compile_2nd_matrix_pseudo_ellipse_torsionless() function has been changed to prevent a divide by zero failure. The surface area normalisation factor now defaults to 0.0. Fixes for all PCS numeric integration for all frame order models in the rigid case. The exact PCS values for the rigid state are now correctly calculated when no Sobol' points lie within the motional model. The identity matrix is used to set the rotation to zero, and the PCS values are now multiplied by the constant. Updates for the chi-squared value in all the Frame_order.test_rigid_data_to_*_model system tests. This is now much reduced as the true rigid state is now being tested for. The rigid frame order matrix for the pseudo-ellipse models is now correctly handled. This allows the rigid case RDCs to be correctly calculated for both the pseudo-ellipse and torsionless pseudo-ellipse models. The previous catch of the θx cone angle of zero was incorrectly recreating the frame order matrix, which really should be the identity matrix. However truncation artifacts due to the quadratic SciPy integration still cause the model to be ill-conditioned near the rigid case. The rigid case is correctly handled, but a tiny shift of the parameters off zero cause a discontinuity. Updates for the Frame_order.test_rigid_data_to_pseudo_ellipse*_model system tests. The chi-squared value now matches the rigid model. Large increase in precision for the CaM frame order torsionless pseudo-ellipse model test data set. In addition, the θx and θy angles have also been swapped so that the new constraint of 0 ≤ θx ≤ θy ≤ π built into the analysis is satisfied. The higher precision is because the number structures in the distribution is now 20 million rather than 1 million and the numpy.float128 data averaging has been used. The algorithm for finding suitable random domain positions within the motional limits has been changed as well by extracting the θ and φ tilt angles from the random rotation, dropping the torsion angle σ, and reconstructing the rotation from just the tilt angles. This increases the speed of the data generation script by minimally 5 orders of magnitude. Changed the parameter values for the Frame_order.test_cam_pseudo_ellipse_torsionless* system tests. The θx and θy angles are now swapped. The chi-squared values are now also lower in the 3 system tests as the data is now of much higher precision. Speedup for the frame order analyses when only one domain is aligned. When only one domain is aligned, the reverse Ln3+ to spin vectors for the PCS are no longer calculated. For most analyses, this should significantly reduce the number of mathematical operations required for the quasi-random Sobol' point numerical integration. Support for the 3 vector system for double motions has been added to the frame order analysis. This is used for the quasi-random Sobol' numeric integration of the PCS. The lanthanide to atom vector is the sum of three parts: the 1st pivot to atom vector rotated by the 1st mode of motion; the 2nd pivot to 1st pivot vector rotated by the 2nd mode of motion (together with the rotated 1st pivot to atom vectors); and the lanthanide to second pivot vector. All these vectors are passed into the lib.frame_order.double_rotor.pcs_numeric_int_double_rotor() function, which passes them to the pcs_pivot_motion_double_rotor() function where they are rotated and reconstructed into the Ln3+ to atom vectors. Fully implemented the double rotor frame order model for PCS data. Sobol' quasi-random points for the numerical integration are now generated separately for both torsion angles, and two separate sets of rotation matrices for both angles for each Sobol' point are now pre-calculated in the create_sobol_data() target function method. The calc_vectors() target function method has also been modified as the lanthanide to pivot vector is to the second pivot in the double rotor model rather than the first. The target function itself has been fixed as the two pivots were mixed up - the 2nd pivot is optimised and the inter-pivot distance along the z-axis gives the position of the 1st pivot. For the lib.frame_order.double_rotor module, the second set of Sobol' point rotation matrices corresponding to sigma2, the rotation about the second pivot, is now passed into the pcs_numeric_int_double_rotor() function. These rotations are frame shifted into the eigenframe of the motion, and then correctly passed into pcs_pivot_motion_double_rotor(). The elimination of Sobol' points outside of the distribution has been fixed in the base pcs_numeric_int_double_rotor() function and now both torsion angles are being checked. Fix for the unpacking of the double rotor frame order parameters in the target function. This is for when the pivot point is being optimised. Created a new synthetic CaM data set for the double rotor frame order model. This is the same as the test_suite/shared_data/frame_order/cam/double_rotor data except that the angles have been increased from 11.5 and 10.5 degrees to 85.0 and 55.0 for the two torsion angles. This is to help in debugging the double rotor model as the original test data is too close to the rigid state to notice certain issues. Corrected the printout from the CaM frame order data generation base script. The number of states used in the distribution of domain positions is now correctly reported for the models with multiple modes of motion. Created a frame order optimisation script for the CaM double rotor test suite data. This is the script used for testing the implementation, it will not be used in the test suite. Created the Frame_order.test_rigid_data_to_double_rotor_model system test. This shows that the double rotor model works perfectly when the domains of the molecule are rigid. Fix for the frame order target functions for when no PCS data is present. In this case, the self.pivot structure was being created as an empty array rather than a rank-2 array with dimensions 1 and 3. This was causing the rotor models to fail, as this pivot is used to recreate the rotation axis. Fix for the CaM double rotor frame order system tests. The torsion angle cone_sigma_max is a half angle, therefore the full angles from the data generation script are now halved in the system test script. Created 3 frame order system tests for the new large angle double rotor CaM synthetic data. These are the Frame_order.test_cam_double_rotor_large_angle, Frame_order.test_cam_double_rotor_large_angle_rdc, and Frame_order.test_cam_double_rotor_large_angle_pcs system tests. Added the full optimisation results for the torsionless pseudo-ellipse frame order model. This is for the CaM test data using the new frame_order.py optimisation script. Added the full optimisation results for the 2nd free rotor isotropic cone frame order model. This is for the CaM test data using the new frame_order.py optimisation script. Small fix for the large angle CaM double rotor frame order model synthetic test data. The way the rotation angle was calculated was slightly out due to integer truncation. The integers are now converted to floats in the generate_distribution.py script and all of the PCS and RDC data averaged over ~20 million states has been recalculated. Added proper support for the double rotor frame order models to the system test scripts. This is for the CaM synthetic data. The base script can now handle the current parameterisation of the double rotor model with a single pivot, an eigenframe, and the second pivot defined by a displacement along the z-axis. The scripts for the double_rotor and double_rotor_large_angle data sets have been changed to use this parameterisation as well. Attempt at implementing the 2nd degree frame order matrix for the double rotor model. This is required for the RDC. The second torsion angle is now printed out for the frame order system tests. This is in the system test class mesg_opt_debug() method and allows for better debugging of the double rotor models. Fix for the Frame_order.test_cam_double_rotor_large_angle* system tests. The system test script was pointing to the wrong data directory. The double rotor frame order system tests are no longer blacklisted. Updated the chi-squared values being checked for the double rotor frame order system tests. Shifted the frame order geometric representation functions into their own module. This is the new specific_analyses.frame_order.geometric module. The frame order geometric representation functions are no longer PDB specific. Instead the format argument is accepted. This will allow different formats to be supported in the future. Because of this change, all specific_analyses.frame_order.geometric.pdb_*() functions has been renamed to create_*(). Created an auxiliary function for automatically generating the pivots of the frame order analysis. This is the new specific_analyses.frame_order.data.generate_pivot() function. It will generate the 1st or 2nd pivot, hence supporting both the single motion models and the double motion double rotor model. Shifted the rotor generation for the frame order geometric representation into its own function. This is the specific_analyses.frame_order.geometric.add_rotors() function which adds the rotors are new structures to a given internal structural object. The code has been extended to add support for the double rotor model. Fix for the pivots created by the specific_analyses.frame_order.data.generate_pivot() function. This is for the double rotor model where the 1st mode of motion is about the 2nd pivot, and the 2nd mode of motion about the 1st pivot. Fixes for the cone geometric representation in the internal structural object. The representation can now be created if the given MoleculeContainer object is empty. Refactored the frame order geometric motional representation code. The code of the specific_analyses.frame_order.geometric.create_geometric_rep() function has been spun out into 3 new functions: add_rotors(), add_axes(), and add_cones(). This is to better isolate the various elements to allow for better control. Each function now adds the atoms for its geometric representation to a separate molecule called 'axes' or 'cones'. The add_rotors() does not create a molecule as the lib.structure.represent.rotor.rotor_pdb() function creates its own. As part of the rafactorisation, the neg_cone flag has been eliminated. Renamed the residues of the rotor geometric object representation. The rotor axis atoms now belong to the RTX residue and the propeller blades to the RTB residue. The 'RT' at the start represents the rotor and this will allow all the geometric objects to be better isolated. Improvements to the internal structural object _get_chemical_name() method. This now uses a translation table to convert the hetID or residue name into a description, for example as used in the PDB HETNAM records to give a human readable description of the residue inside the PDB file itself. The new rotor RTX and RTB residue names have been added to the table as well. Renaming of the residues of the cone geometric representation. The cone apex or centre is now the CNC residue, the cone axis is now CNX and the cone edge is now CNE. These used to be APX, AXE, and EDG respectively. The aim is to make these names 100% specific to the cone object so that they can be more easily selected for manipulating the representation and so that they are more easily identifiable. The internal structural object _get_chemical_name() function now returns a description for each of these. Note that the main cone object is still named CON. The motional pivots for the frame order models are now labelled in the geometric representation. The pivot points are now added as a new molecule called 'pivots' in the frame_order.pdb_model user function. The atoms all belong to the PIV residue. The pymol.frame_order user function now selects this residue, hides its atoms, and then shows the atom name 'Piv' as the label. For the double rotor model, the atom names 'Piv1' and 'Piv2' are used to differentiate the pivots. Renamed the lib.structure.represent.rotor.rotor_pdb() function to rotor(). This function is not PDB specific and it just creates a 3D structural representation of a rotor object. Added support for labels in the rotor geometric object for the internal structural object. The labels are created by the frame_order.pdb_model user function backend. For the double rotor model, these are 'x-ax' and 'y-ax'. For all other models, the label is 'z-ax'. The labels are then sent into the lib.structure.represent.rotor.rotor() function via the new label argument. This function adds two new atoms to the rotor molecule which are 2 Angstrom outside of the rotor span and lying on the rotor axis. These then have their atom name set to the label. The residue name is set to the new RTL name which has been added to the internal structural object _get_chemical_name() method to describe the residue in the PDB file for the user. Finally the pymol.frame_order user function selects these atoms, hides them and then labels them using the atom name (x-ax, y-ax, or z-ax). Modified the rotor representation generated by the pymol.frame_order user function. This is to make the object less bulky. Redesign of the axis geometric representation for the frame order motions. This is now much more model dependent to avoid clashes with the rotor objects and other representations: For the torsionless isotropic cone, a single z-axis is created; For the double rotor, a single z-axis is produced connecting the two pivots, from pivot2 to pivot1; For the pseudo-ellipse and free rotor pseudo-ellipse, the x and y-axes are created; For the torsionless pseudo-ellipse, all three x, y and z-axes are created; For all other models, no axis system is produced as this has been made redundant by the rotor objects. Fixes for the cone geometric object created by the frame_order.pdb_model user function. This was broken by the code refactoring and now works again for the pseudo-ellipse models. Fix for the pymol.frame_order user function. The representation function for the rotor objects was hiding all parts of the representation, hence the pivot labels where being hidden. To fix this, the hiding of the geometric object now occurs in the base frame_order_geometric() function prior to setting up the representations for the various objects. Started to redesign the frame_order.pdb_model user function. Instead of having the positive and negative representations in different PDB models, and the Monte Carlo simulations in different molecules, these will now all be shifted into separate files. For this to be possible, the file root rather than file names must now be supplied to the frame_order.pdb_model user function. To allow for different file compression, the compress_type argument is now used. The backend code correctly handles the file root change, but the multiple files are not created yet. Python 3 fixes using the 2to3 script. Fatal changes to the multi.processor module were reverted. Improvements to the lib.structure.represent.rotor.rotor() function for handling models. The 'rotor', 'rotor2', or 'rotor3' molecule name determination is now also model specific. The frame order generate_pivot() function can now return the pivots for Monte Carlo simulations. This is the specific_analyses.frame_order.data.generate_pivot() function. The sim_index argument has been added to the function which will allow the pivots from the Monte Carlo simulations to be returned. If the pivot was fixed, then the original pivot will be returned instead. Test suite fixes for the recent redesign of the frame_order.pdb_model user function. Fixes for the frame_order.pdb_model user function for the rotor and free rotor models. Redesign of the geometric object representation part of the frame_order.pdb_model user function. The positive and negative representations of the frame order motions have been separated out into two PDB files rather than being two models of one PDB file. This will help the user understand that there are two identical representations of the motions, as both will now be displayed rather than having to understand the model concept of PyMOL. The file root is taken, for example 'frame_order', and the files 'frame_order_pos.pdb' and 'frame_order_neg.pdb' are created. If no inverse representation exists for the model, the file 'frame_order.pdb' will be created instead. The Monte Carlo simulations are now also treated differently. Rather than showing multiple vectors in the axes representation component within one molecule in the same file as the frame order representation, these are now in their own file and each simulation is now a different model. If an inverse representation is present, then the positive representation will go into the file 'frame_order_sim_pos.pdb', for example, and the negative representation into the file 'frame_order_sim_neg.pdb'. Otherwise the file 'frame_order_sim.pdb' will be created. Clean up of the frame_order.pdb_model user function definitions. Some elements were no longer of use, and some descriptions have been updated. Redesign of the pymol.frame_order user function to match the redesign of frame_order.pdb_model. The file names are no longer given but rather the file root. Then all PDB files matching that file root in the given directory will be loaded into PyMOL. Updated all of the frame order scripts for the frame_order.pdb_model and pymol.frame_order changes. These are the scripts for the CaM frame order test data. Redesign of the average domain position part of the frame_order.pdb_model user function. The Monte Carlo simulations are now represented. If the file root is set to the default of 'ave_pos', then these will be placed in the file 'ave_pos.pdb', or a compressed version. Each simulation is in a different model, matching the geometric representation '*_sim.pdb' files. The original structure is copied for each model, and then rotated to the MC simulation average position. Change all of the domain user function calls in the frame order CaM test data scripts. The domains are now identified by the molecule name rather than the range of residues. This allows non-protein atoms, for example the Ca2+ atoms, to be rotated to the average domain position as well. The PyMOL disable command is now used by the pymol.frame_order user function. This is to first disable all PyMOL objects prior to loading anything, to hide the original structures and any previous frame order representations, and then to hide all of the Monte Carlo simulation representations. This is to simplify the picture initially presented to the user while still allowing all elements to be easily found. The pymol.frame_order user function now centers and zooms on all objects. Simplified the PyMOL view commands in all of the CaM test data optimisation scripts. The pymol.view user function is not necessary as the PyMOL GUI will be launched by the pymol.frame_order user function. And the pymol.command user function call for running the 'hide all' command is also now redundant. Removed all remaining uncompressed PDB files from the CaM test data directories. These were complicating the debugging of the pymol.frame_order user function, as they were being loaded on top of the compressed versions. Removed some rotation files from the CaM frame order test data directories. These files are no longer of any use and just take up large amounts of room for nothing. Added titles to the frame order geometric representation PDB files from frame_order.pdb_model. These are in the form of special Ti atoms placed 40 Angstrom away from the pivot along the z-axis of the system, or shifted 3 more Angstrom for the Monte Carlo simulations. These are used to label the alternative representations or the Monte Carlo simulation representations. The residue type is set to TLE and this has been registered in the internal structural object. The pymol.frame_order user function now calls the represent_titles() function to select these atoms, hide them, and then add a long descriptive title. The atom name is used to distinguish between different titles. Changed the alternative representation names for the frame order geometric objects. The aim is to put both representations on a more equal footing, as they are identical solutions. Hence the inverted representation might be the correct representation of the domain motions. So instead of calling these 'positive' and 'negative', the 'A' and 'B' notation will be used. This affects the names of the files produced by the frame_order.pdb_model user function as well as the internal titles. Instead of ending the files with "*_pos.*" and "*_neg.*", these have been changed to "*_A.*" and "*_B.*". The atoms used for the titles have also been renamed, and the pymol.frame_order user function now labels the titles using the 'A' and 'B' notation. Changes to the rotor object in the frame order geometric representations. For the isotropic and pseudo-elliptic cone models, the rotor is now halved. Instead of having two axes radiating from the central pivot and terminating in the propeller blades, now only the positive axis is shown lying in the centre of the cone. Fixes for the MC simulation rotor objects in the frame order geometric representation. The axes of the Monte Carlo simulation rotors objects were being set to the original values and not to the simulation values. Fixes for the titles in the frame order geometric representation from frame_order.pdb_model. There were a few bugs for a number of the frame order models preventing this code from working. Redesign of the geometric representation of the cone structural objects to allow for models. The old representation was not compatible with the PDB model concept whereby each model must have the same number of atoms. To handle this situation, the cone objects have been simplified. Specifically the cone cap. The old behaviour was to remove all points outside of the cone when creating the cone cap, and then to stitch the cap to the cone edge in a subsequent step. Now the behaviour is that all points outside of the distribution are shifted to the cone edge. This avoids the need to stitch the cap to the edge. This behaviour means that all cones with the same inc value will have the same number of atoms. The cones for the pseudo-ellipses are not as nice as the latitudinal lines are not strait at the cone edge, but at least creating multiple models with different cone sizes is now possible. Bug fix for the y-axis rotation matrix for the double rotor Sobol' integration points. The matrix was inverted. Updated the frame order system test chi-squared values for the previous fix. Fixes for the double rotor frame order system tests for the CaM synthetic data. The torsion angles needed to be swapped and the pivot point changed from the C terminal domain CoM to the N domain CoM. More fixes for the double rotor frame order system tests for the CaM synthetic data. The eigensystem was inverted. Updated the χ2 check for the large angle double rotor frame order system tests. This is needed for the eigenframe fix. Updates for the frame order system tests for the float32 to float64 change. Some chi-squared values have slightly changed. The CaM frame order test data optimisation scripts now save more state files. The state of the true dynamics and the fixed pivot optimisation results are now stored as well. This might be useful for extracting these results without redoing the calculations. The script for representing the frame order dynamics for the CaM test data has been updated. The domains of the system are now defined. Changed the CaM frame order test data superimposition values. Because the domains are now defined via the molecule name rather than the residue numbers, the centroid of rotation set to the CoM has been shifted as now the Ca2+ ions are included in the CoM calculation. Therefore the superimpose.py script has been updated to not delete the Ca atoms. All of the frame order optimisation scripts have been updated with the new rotation Euler angles and translation vector. To match this, the system test base script for the CaM frame order test data has also had its rotations and translations updates, and the domain user function call changed to use molecule names. Updated all of the CaM frame order system test chi-squared values. These have changed slightly due to the rotation and translation changes. Added support for the 'pivot_disp' frame order parameter to the grid search. This is required for the double rotor model. Changed some of the default values for the frame order auto-analysis. The number of Sobol' quasi-random integration points were far too low to obtain any reasonable results. Simplified the PyMOL visualisation relax script created by the frame order auto-analysis. This now consists of a single pymol.frame_order user function call. The other pymol user function calls were unnecessary. Added the full optimisation results for the large angle double rotor frame order model. This is for the CaM test data using the new frame_order.py optimisation script. Added model support for the rotor geometric object. This is the structural object used in the frame order analysis to create PDB representations of rotor motions. The number of atoms created for the rotor is now constant, allowing for models whereby the atom number and connectivity must be preserved between all models. Changed the grid search pivot displacement frame order parameter. Instead of searching from 0 to 50 Angstroms, the search is now from 10 to 50. This is to avoid the edge case of pivot_disp = 0.0 from which the optimisation cannot escape. Speedup of the PCS component of the rigid frame order model. The lanthanide to atom vectors are now being calculated outside of the alignment tensor and spin loops, as well as the inverse vector lengths to the 5th power. This increases the speed by a factor of 1.216 (from 38.133 to 31.368 seconds for 23329 calls of the func_rigid() target function). Added the full optimisation results for the rigid frame order model. This is for the CaM test data using the new frame_order.py optimisation script. Numpy ≤ 1.6 fixes for the frame order PCS code. The numpy.linalg.norm function does not have an axis argument in numpy 1.6, therefore the lib.compat.norm() function is now used instead. This function was created exactly for this axis argument problem. Created the new specific_analyses.frame_order.variables module. This currently contains variables for all of the frame order model names, as well as various lists of these models. The rest of the frame order specific analysis code as well as the frame order user functions have been converted to use these model variables exclusively rather than having the model name strings hardcoded throughout the codebase. Added the full optimisation results for the double rotor test data. This is for the CaM frame order test data using the new frame_order.py optimisation script. Added a script for profiling the target function calls of the pseudo-ellipse frame order model. Added a timeit script and log file showing how numpy.cos() is 10 times slower than math.cos(). This is for single floats. Shifted the calculation of the θmax cone opening for the pseudo-ellipse outside of all loops. This is infrastructure change for potentially eliminating all of the looping for the PCS numeric integration in the future. It however slightly speeds up the pseudo-ellipse frame order model. Using 500 target function calls in the profiling_pseudo_ellipse.py script in test_suite/shared_data/frame_order/timings/, the time spent in the pcs_pivot_motion_full_qrint() function decreases from 20.849 to 20.719 seconds. Converted the torsionless pseudo-ellipse model to also use the tmax_pseudo_ellipse_array() function. This allows the calculation of the pseudo-elliptic cone opening θmax to be shifted outside of all loops. Created a profiling script and log file for the isotropic cone frame order model. This shows where the slow points of the model are, using 2000 target function calls. Increased the function call number to 500 in the pseudo-ellipse frame order model profiling script. The profiling log file has also been added to show where the slowness is - specifically that the numeric PCS integration takes almost the same amount of time as the RDC frame order matrix construction using the scipy.integrate.quad() function. Created the specific_analyses.frame_order.checks.check_pivot() function. This is to check that the pivot point has been set. The frame order grid search is now checking if the pivot point has been set. Added a profiling script and log file for the free rotor frame order model. Updated the frame order optimisation results for the CaM isotropic cone test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository and the old ones removed. Modified the script for recreating the frame order PDB representation and displaying it in PyMOL. The state loading, domain redefinition, and representation creation parts have all been removed, as these will soon all be redundant as the frame order analysis for all models is being redone. All that remains are the pymol.frame_order() function calls for displaying all the representations. The pivot point parameters in the frame order analysis are no longer scaled by 100. This is to match the average domain position translation which is also not scaled. The specific_analyses.frame_order.variables module is now used throughout the frame order code. The target function code, auto-analysis, and test suite now all use the variables defined in this module rather than having hardcoded strings. The MODEL_LIST_NONREDUNDANT variable has been created to exclude the redundant free rotor pseudo-ellipse which cannot be optimised, and this is used by the auto-analysis. Removal of many unused imports in the frame_order_cleanup branch. These were detected using the devel_scripts/find_unused_imports.py script which uses pylint to find all unused imports. The false positives also present in the trunk were ignored. And the unused imports in the dispersion code were also left for clean up the disp_spin_speed branch. Changed the minimisation in the frame order system tests where optimisation is activated. The number of iterations is now set to 1 for speed testing, and the constraints are turned on. Turned on the optimisation flag for the Frame_order.test_cam_free_rotor system test. This is to activate code paths currently not tested by the test suite. Constraints are now properly turned off in the minimise user function for the frame order analysis. The A and b matrices from linear_constraints() are now set to None if they are returned as empty arrays. Parallelised the frame order optimisation code to run on clusters or multi-core systems via OpenMPI. The optimisation code has been split into the three standard parts of the multi-processor: 1) Frame_order_memo is the new Memo object used to store data on the master for use when data is returned from the slaves. 2) Frame_order_minimise_command is the Slave_command which stored all required data for the optimisation, is pickled and sent to a slave, sets up the target function, and then performs optimisation. 3) Frame_order_result_command is the Result_command initialised by the Slave_command on the slave for pickling and returning results to the master. To avoid pickling the target function class, which is not possible, the store_bc_data() and target_fn_setup() functions of the specific_analyses.frame_order.optimisation module have been redesigned to work with basic data structures rather than the target function class directly. The target_fn_setup() function no longer returns an initialised target function class, but rather all the data assembled prior to the initialisation. And the target function class was itself modified so that pcs_theta and rdc_theta are always defined to allow the store_bc_data() function to be used successfully. This parallelisation currently only allows the Monte Carlo simulations to be run on slave processors. The frame order linear_constraints() function now returns None if no constraints are present. This allows the code using this to be simplified with respect to turning off the constraints. Improvements for the printout at the start of optimisation of the frame order models. This is in the target_fn_setup() frame order method. All the printouts are now in one place and they are now better formatted and better controlled. Parallelised the frame order grid search to run on clusters or multi-core systems via OpenMPI. This involved the creation of the Frame_order_grid_command class which is the multi-processor Slave_command for performing the grid search. This was created by duplicating the Frame_order_minimise_command class and then differentiating both classes. For the subdivision of the grid search, the new minfx grid.grid_split_array() function is used in the frame order grid() API method. The grid() method no longer calls the minimise() method but instead obtains the processor box itself and adds the subdivided grid slaves to the processor. The relax grid_search user function takes care of the rest. Fixes for the parallelised grid search for the frame order analysis. A chi-squared value check was added to the Frame_order_result_command.run() method to check if the value is lower than the current when the result is returned to the master. Without this check, each grid subdivision result will be stored as they are returned rather than storing the results from the global minimum of the entire grid search. Added a script for testing out the parameter nesting abilities of the frame order auto-analysis. This script attempts to find the dynamics solution without knowing where the pivot is located. Hence this will be as in the auto-analysis were this pivot point will be used as the base for all other models. Sent the verbosity argument to the minfx.grid.grid_split() function for the frame order analysis. This matches the relax trunk changes for the model-free analysis. The minfx function in the next release (1.0.8) will now be more verbose, so this will help with user feedback when running the model-free analysis on a cluster or multi-core system using MPI. Improvements for the parallelised grid search for the frame order analysis. As each grid point can take wildly different numbers of CPU cycles to calculate the chi-squared value for, the result of subdividing the grid search was that some subdivisions where incredibly quick while others required much larger amounts of time. To avoid this bad slave management, the grid points are now randomised. This means that the subdivisions will require about the same amount of time to optimise. Moved the setup of the target function data structures in the frame order analysis. This is for the grid_search and minimise user functions. The target function data setup function has been renamed to target_fn_data_setup(). This is now called before the Frame_order_grid_command and Frame_order_minimise_command multi-processor objects are initialised, and all of the data is now passed into these functions. Although the code is uglier, this has the benefit that the target_fn_data_setup() function will only be called once. This data setup requires a lot of time, so for a large cluster, this can be a large time saving for the grid search. Modified the frame_order_free_start.py script to better mimic the frame order auto-analysis. Updated the frame order optimisation results for the 2nd CaM free rotor test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the CaM free rotor test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the CaM missing data free rotor test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the CaM free rotor isotropic cone test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the CaM small angle rotor test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the 2nd CaM free rotor isotropic cone test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the CaM pseudo-ellipse test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the CaM torsionless isotropic cone test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the 2nd CaM pseudo-elliptic cone test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Some more fixes for the optimisation user function changes. Removed the parameter scaling for the pivot point frame order parameters. These were already removed from the frame_order_cleanup branch in the assemble_scaling_matrix() function, however they were reintroduced accidentally via the parameter object where this information is now defined. So this removes the scaling a second time. Fixes for the parameter scaling changes in the trunk. The scaling flag is no longer part of the specific analysis API optimisation methods. Instead the pre-assembled scaling matrices are passed into all three API optimisation methods. Implemented the frame order specific analysis API method print_model_title(). This is simply aliased from the API common method _print_model_title_global(). Fix for the grid search in the frame order analysis. This is a recently introduced problem due to the changes of the zooming_grid_search branch. Turned on the optimisation in the Frame_order.test_cam_rigid system test. This is to catch a number of failures in the frame order grid search. Activated the grid search in the frame order system tests using the CaM synthetic data. This is set to one increment so that the tests can complete in a reasonable time. Fix for the specific_analyses.frame_order.optimisation.grid_row() function. This can now handle the case of a single grid increment. The change is similar to r163 in the minfx project. Converted the frame_order_free_start.py script to use the zooming grid search. Added lots of calls to the time user function to the frame_order_free_start.py. This will be used to fine tune the frame order analysis on a cluster. Increased the default grid bounds for the pivot parameters of the frame order models. The pivot point is now searched for in a 50 Angstrom box and the pivot displacement for the double motion models from 10 to 60 Angstroms. These were originally a 20 Angstrom box and 10 to 50 Angstroms. The larger grid is possible when combined with the new zooming grid search. Updated the frame order optimisation results for the 2-site CaM test data fitting to the rotor model. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the CaM rotor test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the 2nd CaM rotor test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Fixes for the CaM free-rotor pseudo-ellipse frame order model test data set. This is for the constraint 0 ≤ θx ≤ θy ≤ π, as the old data was created with θx > θy. The new data is also of high quality using 20 million structures and numpy.float128 data averaging. Created the lib.frame_order.rotor_axis.convert_axis_alpha_to_spherical() function. This will convert the axis α angle to the equivalent spherical angles θ and φ. Renamed the lib.frame_order.rotor_axis module to lib.frame_order.conversions. This module will be used for all sorts of frame order parameter conversions. Added the pipe_name argument to the specific_analyses.frame_order.data.generate_pivot() function. This allows the pivot from data pipes other than the current one to be assembled and returned. Updated the frame order optimisation results for the CaM free rotor, pseudo-ellipse test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Updated the frame order optimisation results for the CaM torsionless, pseudo-ellipse test data. The optimisation in the frame_order.py is now of higher precision with the number of Sobol' numeric integration points significantly increased, especially for the Monte Carlo simulations. The new frame order representation files have been added to the repository, as well as the intermediate state files. Fix for the Frame_order.test_cam_pseudo_ellipse_free_rotor system test. This is for the change of the X and Y cone opening angles. Redesign and expansion of the nested model parameter copying in the frame order auto-analysis. The nested parameter protocol used to allow the analysis to complete in under 1,000,000 years was no longer functional due to the switching to the axis α parameter to decrease parameter number and redundancy. The copying of the average domain position for the free rotor models was also incorrect as the dropping of the α Euler angle cause the translation parameters and β and γ angles to change drastically. The new protocol has been split into four methods for the average domain position, the pivot point, the motional eigenframe and the parameters of ordering. These use the fact that the free rotor and torsionless models are the two extrema of the models where the torsion angle is restricted. The pivot copying is a new addition. Created the Frame_order.test_auto_analysis system test. This will be an extremely quick run through of the frame order auto-analysis as this is not currently tested. 1 Sobol' quasi-random integration point will be used for all models for speed. The system test uses the rigid CaM test data to perform a full analysis. Alphabetical ordering of the imports in the frame order auto-analysis module. Fixes for the backend script of the Frame_order.test_auto_analysis system test. This includes a missing import and the removal of a long ago deleted user function. Fix for the frame order auto-analysis for the call to the grid search user function. This user function has been renamed to minimise.grid_search, however not all parts of the analysis had been converted to the new name. Created a method in the frame order auto-analysis to reorder the models. This is needed as the nested model parameter copying protocol requires the simpler models to be optimised first. The Frame_order.test_auto_analysis system test now writes all files to the directory of ds.tmpdir. This is to prevent the system test from dumping files in the current directory. Modified the specific_analyses.frame_order.parameters.update_model() function. This will no longer set all parameters to 0.0, excluding the pivot point. Modified the specific_analyses.frame_order.parameters.assemble_param_vector() function. This can now handle the case of no parameters being present. The corresponding elements of the numpy array will consist of NaN values. Better handling of unset parameters in the frame order optimisation functions. The specific_analyses.frame_order.optimisation.target_fn_data_setup() and specific_analyses.frame_order.parameters.assemble_param_vector() function both now accept the unset_fail argument. This is set in both the calculate() and minimise() API methods. When set, a RelaxError will be raised in the assemble_param_vector() function when a parameter has not been set yet. This together with previous changes will prevent the frame order analysis from using 0.0 as a starting value for unset parameters. Fixes for all of the Frame_order.test_rigid_data_to_*_model system tests. The base script now sets all parameter values so that the minimise.calculate user function can operate. The two free rotor model chi-squared values have been updated as these are sensitive to the motional eigenframe parameter values - these models can never approximate a rigid state. Modified the optimisation of the rigid model in the frame order auto-analysis. The grid search is now implemented as a zooming grid search. Updates and fixes for the frame order auto-analysis. The custom grid setup now works for the new reduced parameter set models and the double rotor model is now also included. The cone axis α angle to spherical angle conversion has had a bug removed. And some of the printouts are now more detailed. Redesigned the Frame_order.test_auto_analysis system test. This now uses a hypothetical new Optimisation_settings object from the frame order auto-analysis module for holding all of the grid search, zooming grid search and minimisation settings. This will allow for far greater user control of the settings and hugely simplify the auto-analysis interface by decreasing the number of input arguments. It should also be less confusing. Implementation of the Optimisation_settings object in the frame order auto-analysis. This object holds all of the grid search, zooming grid search, and minimisation settings. It provides the add_grid() and add_min() methods to allow the user to add successive iterations of optimisation and settings to the object. The loop_grid() and loop_min() methods are used to loop over each iteration of each method. And the get_grid_inc(), get_grid_num_int_pts(), get_grid_zoom_level(), get_min_algor(), get_min_func_tol() and get_min_num_int_pts() methods are used to access the user defined settings. The auto-analysis has been redesigned around this new concept. All of the optimisation arguments have been replaced. Instead there are the opt_rigid, opt_subset, opt_full, and opt_mc arguments which are expected to be instances of the Optimisation_settings object. The optimisation in the auto-analysis is now more advanced in that more user optimisation settings are now available and active. Added linear constraints for the pivot and average domain translation frame order parameters. The pivot coordinates are constrained between -999 and 999 Angstrom and the translation between -500 and 500 Angstrom. This allows the frame_order.pdb_model user function to operate in the case of failed models - often the free rotors fitting to torsionally restricted data - by preventing the PDB coordinates from being out of the PDB format range. It should also speed up optimisation by stopping the optimisation of failed models earlier. The frame order auto-analysis Optimisation_settings object now handles the maximum iterations. The new max_iter argument has been added to the add_min() method, and the new get_min_max_iter() method added to fetch the value. This is used in the auto-analysis to set the maximum number of optimisation iterations in the minimise.execute user function calls. Limiting this will be of greatest benefit for the test suite. Speedup of the Frame_order.test_auto_analysis system test. This involves limiting the maximum number of optimisation steps to 20 for most parts (the rigid model excluded so the average domain position is correctly found), and using the PCS subset data for the full data set. Updated the full_analysis.py script for the CaM frame order test data. This is for the recent changes to the auto-analysis with the Optimisation_settings object and for the changes of this branch. Removed the RDC data checks from the frame order optimisation. This is in the minimise_setup_rdcs() and store_bc_data() functions of the specific_analyses.frame_order.optimisation module, called before and after all optimisation. The reason was identified by profiling - this check was adding significant amounts of time to the setup and results unpacking parts of the optimisation. Specifically the interatomic_loop() function was identified via profiling as the function requiring the most amount of cumulative time in the Frame_order.test_auto_analysis system test (17 seconds out of a total of ~60 seconds). Fixes for the removal of the RDC data checks from the frame order optimisation functions. The specific analysis API method overfit_deselect() has now been created to deselect spins which do not have PCS data or interatomic data containers missing RDC data. The handling of deselected spins and interatomic data containers is now also correctly handled throughout the frame order specific code. Enabled pivot optimisation in the full_analysis.py script for the CaM frame order test data. The frame order auto-analysis now calls the time user function. This is used at the start of each model section, as well as at the very start and very end of the analysis. This feedback is needed for the user to be able to optimise the optimisation settings. Major bugfix for the frame order auto-analysis. The algorithm of using a PCS data subset of a few selected residues to find an initial parameter estimate followed by using all PCS data was badly implemented. The use of the PCS subset caused most spin systems to be deselected, however they remained deselected once all data was being used. So the result was that only the spin subset was ever being used in the analysis. Fix for the recent lib.period_table and lib.physical_constants module changes. Created the model_directory() method for the frame order auto-analysis. This is used to create the full path for saving model specific files. It replaces spaces with underscores in the path and removes all commas. The commas in the path appear to be fatal for certain PyMOL versions when viewing the frame order representation. The frame order auto-analysis results printout has been extended to include the pivot point. Change to the parameter nesting in the frame order auto-analysis. The pivot is now taken from the rotor model for all other models. Taking the pivot point from the isotropic cone model is not a good idea as there are situations where the pivot point optimisation catastrophically fails, sending the point many tens or hundreds of Angstrom away from the molecule. Copied a frame order results file for testing axis permutations. This is from the test_suite/shared_data/frame_order/cam/pseudo_ellipse/ directory. The optimisation results were identified to have failed, in that it found the alternative minimum. The pseudo-ellipse model as two minima in the space, and in this case the global minimum was missed. Created the Frame_order.test_axis_permutation system test. This is to test the operation of the yet-to-be implemented frame_order.permute_axes user function. Implemented the frame_order.permute_axes user function. This is used to switch between local minima in the pseudo-elliptic frame order models. Fix for the Frame_order.test_axis_permutation system test. The motional eigenframe in the old log file was not exactly correct and did not correspond exactly to the Euler angles in the cam_pseudo_ellipse.bz2 results file in test_suite/shared_data/frame_order/axis_permutations/. Extended the Frame_order.test_axis_permutation system test to check frame_order.permute_axes twice. This will check that two calls to the frame_order.permute_axes user function will restore the original parameter values. The frame_order.permute_axes user function can now handle the torsionless pseudo-ellipse. This model does not have the variable cdp.cone_sigma_max set. Added support for axis permutations in the frame order auto-analysis. This is done by copying the data pipe of the already optimised pseudo-elliptic models, permuting the axes, and performing another optimisation using all RDC and PCS data. This allows the second solution for these pseudo-elliptic models to be found. The 2nd pipe is included in the model selection step to allow the best solution for the model to be found. Fix for the reading of old results files in the frame order auto-analysis. The directory name is now processed by the model_directory() method. This will convert the spaces to '_' and remove commas. Without this the already created files could not be found, if the model name contains a space or comma. Made the pivot point in the frame order PDB representation fail-proof. If the pivot position was outside of the bounds [-1000, 1000], the PDB file creation would fail as the record would be too long. So now the pivot is shifted to be in these bounds. The axis permutation step in the frame order auto-analysis is now always performed. If an old results file was found, this step was accidentally skipped. Added extensive printouts to the frame_order.permute_axes user function. Redesigned the frame_order.permute_axes user function frontend. Previously only cyclic permutations were considered, however non-cyclic permutations are also allowed when accompanied by an axis inversion. Therefore 3 combinations exist with cone_theta_x ≤ cone_theta_y, or 2 when the current combination is excluded. Created 6 system tests for the frame_order.permute_axes user function. This covers the 3 starting conditions (x<y<z, x<z<y, z<x<y) and the two permutations ('A' and 'B') for each of these which do not include the starting permutation. They replace the original Frame_order.test_axis_permutation system test with the tests Frame_order.test_axis_perm_x_le_y_le_z_permA, Frame_order.test_axis_perm_x_le_y_le_z_permB, Frame_order.test_axis_perm_x_le_z_le_y_permA, Frame_order.test_axis_perm_x_le_z_le_y_permB, Frame_order.test_axis_perm_z_le_x_le_y_permA, and Frame_order.test_axis_perm_z_le_x_le_y_permB. Implemented the new frame_order.permute_axes backend. The 3 starting conditions x<y<z, x<z<y, and z<x<y and the two permutations 'A' and 'B' (for each of these which do not include the starting permutation) are now supported. For these 6 combinations, the axis and order parameter permutation and the z-axis inversion are selected and applied to the current system. Removed the second permutation from the 6 Frame_order.test_axis_perm_* system tests. A second identical permutation does not necessarily restore the original state. Fix for the frame_order.permute_axes for the torsionless pseudo-ellipse model. The data structure cdp.cone_sigma_max does not exist in this model as cone_sigma_max == 0.0. Modified the frame order auto-analysis axis permutation algorithm to handle both permutations. Instead of creating one additional data pipe for the permutations, two are now created for the permutations 'A' and 'B'. This allows all 3 solutions for the pseudo-elliptic models to be explored and included in the final model selection process. Fix for the Frame_order.test_axis_perm_x_le_z_le_y_permB system test. The permuted z-axis needs to be inverted in the test. Many fixes for the frame_order.permute_axes user function. The z-axis inversion is now encoded into a 3D numpy array as the index of the new z-axis position needs to be stored. The cone_theta_x, cone_theta_y and cone_sigma_max parameters are now permuted in reverse 'perm' data structure by calling its index() method. And the cone_theta_x - cone_theta_y to y-axis - x-axis switch has been removed (this may need to be reintroduced later). Fix for the axis permutation protocol in the frame order auto-analysis. The pipe.copy user function does not switch pipes, therefore the pipe.switch user function is now being called so that the correct pipe is being permuted and optimised. Created some test data files for visualising the frame order axis permutation. This uses the CaM frame order synthetic data for the rotor model to visualise the pseudo-ellipse frame order model axis permutations. The initial conversion sets the pseudo-ellipse torsion angle cone_sigma_max to the rotor opening half-angle, and the pseudo-elliptic cone opening to close to zero. Then the axis permutations are performed. All three solutions are optimised. PDB representations before and after optimisation are included to illustrate any problems. Bug fix for the new frame_order.permute_axes user function. The cone and torsion angles were not being correctly permuted. Now the direct permutation array is being used. And the fact that cone_theta_x is a rotation along the y-axis and cone_theta_y along the x-axis is taken into account. Redesign of the axis permutation algorithm of the frame_order.permute_axes user function. Instead of tracking the fact that cone_theta_x is a rotation around the y-axis and cone_theta_y is about the x-axis, now two permutation arrays are created - one for the three angles and one for the axes. The permutation array values have also been completely changed as previously the incorrect inverse permutation was coded into the algorithm. Updated the frame order pseudo-ellipse motion permutation test data. This is for the CaM frame order rotor model synthetic data. The correct axis and cone angle permutations of the frame_order.permute_axes user function are now being used and optimised. Renamed the pseudo-ellipse permutation directory to perm_pseudo_ellipse_x_le_y_le_z. This is for the CaM frame order rotor model synthetic data. Fix for the frame_order.permute_axes user function. One of the 6 permutations had the x and y axes switched (the x ≤ z ≤ y condition, permutation A). Visualisation files for all of the pseudo-ellipse permutations by frame_order.permute_axes. This includes the x ≤ z ≤ y and z ≤ x ≤ y conditions (the previous files were for x ≤ y ≤ z). In all permutation combinations, optimisation has been performed to demonstrate that these are all local minima. These all approximate the rotor when using the CaM frame order rotor model synthetic data. Added support for the isotopic cone models to the frame_order.permute_axes user function. This is a simpler setup, but it uses the same permutation algorithm as derived for the pseudo-ellipse models. Instead of setting the x and y cone angles separately, they are instead averaged. And as the cone axis is undefined in the xy plane, the axis has been randomly selected as being the axis perpendicular to both the z-axis and the reference frame x-axis. Created set of files showing the axis permutation problem for the isotopic cone frame order model. This shows that there are two minima. However one has a chi-squared value of ~1, and the other a value of ~150. Nevertheless, the optimisation could be trapped in the non-global minimum so the frame_order.permute_axes user function should be used for the isotopic cones as well, just in case. Created the other isotropic cone condition z ≤ x = y. As there are no constraints in this model, this condition should not result in any major differences, just the size of the cone being different and the optimisation having to decrease the cone angle significantly to mimic the rotor. Modified the frame order auto-analysis. The axis permutation algorithm is now performed on all isotopic cone and pseudo-ellipse models. This is just in case the non-global minima was found in the original optimisation. The isotropic cone models possess two local minima whereas the pseudo-ellipse models possess three local minima. Simplified the optimisation in the axis permutation part of the frame order auto-analysis. Only the last, highest quality setting is used for optimisation. Fix for the axis permutation protocol in the frame order auto-analysis. This would fail if a results file for the permuted model already exists as the pipe.copy user function call was being performed too early. Created set of files for the axis permutation of the torsionless isotopic cone frame order model. Created an initial Frame_order.test_frame_order_pdb_model_ensemble system test. This is to check the operation of the frame_order.pdb_model user function when an ensemble of structures is encountered. However as this uses a very minimal number of user functions to set up the system, a number of other minor bugs will probably be uncovered. Added printouts to the specific_analyses.frame_order.parameters.update_model() function. This is to make it easier to understand why certain things fail due to the system not being fully set up. Simplified the operation of the frame_order.select_model user function. This is by removing the check of PCS data from the specific_analyses.frame_order.data.pivot_fixed() function using the base_data_types() function call. This allows the model to be set up more easily. Modified the frame order check_pivot() function to operate on any data pipe. The function now accepts the pipe_name argument so that checks can happen on any data pipe. Missing imports in the specific_analyses.frame_order.checks module. This is from the recent pipe_name argument addition in the check_pivot() function. The frame order generate_pivot() function can now handle no pivot being present. At the start of this specific_analyses.frame_order.data module function, the check_pivot() function is being called to make sure that a pivot is present. Modified the Frame_order.test_frame_order_pdb_model_ensemble system test so it is set up correctly. The pivot point and moving domain are now specified. Added Monte Carlo simulations to the Frame_order.test_frame_order_pdb_model_ensemble system test. This is only setting up Monte Carlo simulation data structures via the monte_carlo.setup user function. This demonstrates a failure of the frame_order.pdb_model user function when an ensemble of structures is present with Monte Carlo simulations. Added support for the model argument for the frame_order.pdb_model user function. This argument is used to specify which of the models in an ensemble will be used to represent the average domain position Monte Carlo simulations, as each simulation is encoded as a model, as well as for the distribution of structures simulating the motion of the system. The argument is therefore passed into the create_ave_pos() and create_distribution() functions of the specific_analyses.frame_order.geometric module. To handle all models being used in the non Monte Carlo simulation PDB file and only one in this file, the internal structural object is copied twice. The second copy for the MC sims has all but the chosen model deleted out of it. Fix for the Frame_order.test_frame_order_pdb_model_ensemble system test. More needed to be done to set up the Monte Carlo simulations - the monte_carlo.initial_values user function call was required. Modified the frame order sim_init_values() API method to handle missing optimisation data. The monte_carlo.initial_values user function was failing if optimisation had not been performed. This is now caught and handled correctly. Created the Frame_order.test_frame_order_pdb_model_failed_pivot system test. This simply shows how the frame_order.pdb_model user function currently fails if the optimised pivot point is outside of the PDB coordinate limits of "%8.3f". The frame_order.pdb_model user function can now properly handle a failed pivot optimisation. This is when the pivot point optimises to a coordinate outside of the PDB limits. Now all calls to specific_analyses.frame_order.data.generate_pivot() from the module specific_analyses.frame_order.geometric set the pdb_limit flag to True. This allows all representation objects to be within the PDB limits. The algorithm in generate_pivot() has been extended to allow higher positive values, as the real PDB limits are [-999.999, 9999.999]. And a RelaxWarning is called when the pivot is outside to tell the user about it. Modified the frame order auto-analysis to be more fail-safe. Almost all of the protocol is now within a try-finally block so that the execution lock will always be released. Fix for the specific_analyses.frame_order.data.pivot_fixed() function. This was recently introduced when the check for PCS data was removed from this function. To fix the problem, instead of calling base_data_types() to see if PCS data is present, the cdp.pcs_ids data structure is checked instead. Fix for the model argument for the frame_order.pdb_model user function. The deletion of structural models for the Monte Carlo simulations in the average domain position representation now only happen if more than one model exists. Modified the Frame_order.test_frame_order_pdb_model_failed_pivot system test. This is to show that the frame_order.pdb_model user function fails if the pivot is close to but still within the PDB coordinate limits. Modified the pivot position checking in specific_analyses.frame_order.data.generate_pivot(). Now the pivot is shifted to be within the limits shrunk by 100 Angstrom. This allows any PDB representation created by the frame_order.pdb_model user function to be within the PDB limits. Fix for the axis permutation protocol in the frame order auto-analysis. If a results file was found for one of the permutations, a return from the function would occur. The result is that the other permutations would not be loaded or optimised. Fix for the RelaxError raised by the frame_order.select_model user function. This is the error if the model name is incorrect. Created the Frame_order.test_pseudo_ellipse_zero_cone_angle system test. This is to catch a bug in optimisation when the cone_theta_x is set to zero in the pseudo-ellipse models. Bug fix for the lib.frame_order.pseudo_ellipse.tmax_pseudo_ellipse_array() function. The problem was that when θx or θy were zero, the floating point value of 0.0 would be returned. This is the incorrect behaviour as the returned value must be an array matching the dimensions of the φ angle array argument. Fix for the Pseudo_elliptic cone object for when the cone angles are zero. The Pseudo_elliptic.phi_max() method now avoids a divide by zero error. Updates for all of the Frame_order.test_axis_perm_* system tests. The axis permutations and angle permutations are now performed correctly within the tests themselves. This allows the tests to pass. Modified the Frame_order.test_pseudo_ellipse_zero_cone_angle system test to be quick. Now that the test passes, the optimisation needs to be short. So a maximum of two iterations are now set. Otherwise the test would take hours to complete. Small speedup of the Frame_order.test_auto_analysis system test. Alphabetical ordering of most of the Frame_order system tests. Created the very simple Frame_order.test_num_int_points system test. This simply creates a data pipe and calls the frame_order.num_int_pts user function to test its operation. This is to increase the test suite coverage of this user function. Created the Frame_order.test_num_int_pts2 system test. This checks the operation of the frame_order.num_int_pts user function when only the model has been chosen. Renamed the Frame_order.test_num_int_points system test to Frame_order.test_num_int_pts. Created the check_domain() function for the frame order analysis. This is in the specific_analyses.frame_order.checks module. The function checks that the reference domain has been specified. Created the check_model() function for the frame order analysis. This is in the specific_analyses.frame_order.checks module. The function checks that the frame order model has been selected via the frame_order.select_model user function. The frame_order.ref_domain user function backend now uses the check_domain() function. Created the check_parameters() function for the frame order analysis. This is in the specific_analyses.frame_order.checks module. The function checks that the frame order parameters have been set up and have values. Created the Frame_order.test_num_int_pts3 system test. This checks the operation of the frame_order.num_int_pts user function when the model has been and the frame order parameters have been set up. Created the Frame_order.test_count_sobol_points system test. This will test that the frame_order.num_int_pts user function can correctly count the number of Sobol' integration points used for the current set of parameter values. This frame_order.num_int_pts functionality does not exist yet. Implementation of the specific_analyses.frame_order.optimisation.count_sobol_points() function. This is used by the frame_order.num_int_pts user function to provide a printout of the number of Sobol' integration points used for the current parameter values. This is to provide user feedback so that it is know if enough Sobol' points have been used. Modified the Frame_order.test_count_sobol_points system test. The number of points has been massively decreased as generating Sobol' points takes a long time, and the check for the number of used Sobol' points has been set to the real value. Created the Frame_order.test_count_sobol_points2 system test. This checks the operation of the frame_order.count_sobol_points user function. As this user function has not been implemented yet, the test currently fails. Created the frame_order.count_sobol_points user function. This is simply a frontend to the new specific_analyses.frame_order.optimisation.count_sobol_points() function. Updated the Frame_order.test_count_sobol_points2 system test for the correct number of Sobol' points. Created the Frame_order.test_count_sobol_points_rigid system test. This is to demonstrate a failure of the frame_order.test_count_sobol_points user function when applied to the rigid frame order model. Fix for the frame_order.count_sobol_points user function for the rigid model. This model is now caught at the start, a message printed out, and the function exited. Fix for the Frame_order.test_count_sobol_points_rigid system test. This now checks that cdp.used_sobol_points does not exist for the rigid frame order model after a call to the frame_order.count_sobol_points user function. Created the Frame_order.test_count_sobol_points_rotor system test. This is to test the frame_order.count_sobol_points user function for the rotor model. Fix for the frame_order.count_sobol_points user function for the rotor model. The σ angles unpacking required a dimensionality collapse in the Sobol' angle data structure. Updated the number of points to allow the Frame_order.test_count_sobol_points_rotor system test to pass. The frame order count_sobol_points() function is now being called by all of minimise user functions. This occurs at the end of the minimise.calculate, minimise.grid_search, and minimise.execute user function backends to provide more feedback to the user as to the quality of the optimisation. To avoid initialising the target function twice, the count_sobol_points() function now accepts the initialised target function as an optional argument. Created the Frame_order.test_count_sobol_points_free_rotor system test. This is to demonstrate that the frame_order.count_sobol_points user function currently fails for the free-rotor model. Fix for the frame_order.count_sobol_points user function for the free-rotor models. The torsion angle is now correctly handled as the 3 free-rotor models do not have cdp.cone_sigma_max set. Updated the number of points in the Frame_order.test_count_sobol_points_free_rotor system test. This is to allow the test to pass. Fix for the frame order count_sobol_points() function. The checks for the model, parameter and domain set up must come first, before cdp.model is accessed. Otherwise the frame_order.num_int_pts user function will often fail. Fix for the frame order count_sobol_points() function. The free-rotor isotropic cone model was incorrectly handled, as the cone parameter is 'cone_s1' and not 'cone_theta'. The order parameter is now converted to an angle before checking if the Sobol' point is outside of the cone or not. More fixes for the frame order count_sobol_points() function. The torsion angle for the torsionless models is no longer accessed, and the cone_theta parameter is only accessed for models with this parameter. Created the Frame_order.test_count_sobol_points_iso_cone_free_rotor system test. This is to test the frame_order.count_sobol_points user function for the free-rotor isotropic cone model. Fix for the frame order count_sobol_points() function. The torsion angle ranges from -π to π, so the absolute value needs to be checked, just as in the lib.frame_order modules. Updates for the number of Sobol' points in the Frame_order.test_count_sobol_points_* system tests. This is simply to allow all Frame_order system tests to pass. Redesigned the frame_order.num_int_pts user function frontend for the oversampling idea. The use of the quasi-random Sobol' sequence for numerical PCS integration will be modified to use the concept of oversampling. Instead of specifying the exact number of points in the Sobol' sequence and then removing points outside of the current parameter values, the algorithm will oversample as N * Ov * 10M, where N is the maximum number of Sobol' points to be used for the integration, Ov is the oversampling factor, and M is the number of dimensions or torsion-tilt angles used in the system. The aim is to try to use the maximum number of points N for all frame order models and all ranges of dynamics. Renamed the frame_order.num_int_pts user function to frame_order.sobol_setup. The user function no longer specifies the number of integration points. Instead it now specifies the maximum number of points N and oversampling factor Ov used to generate the oversampled Sobol' sequence. Implemented the Sobol' sequence oversampling in the frame order target function class. Converted all of the specific_analyses.frame_order package to the Sobol' point oversampling design. The correct values are now sent into the target function and all references to cdp.num_int_pts has been replaced with the cdp.sobol_max_points and cdp.sobol_oversample pair of variables. The frame_order.count_sobol_points user function backend has also been updated to show the total number of oversampling points and the number of points used. The frame_order.count_sobol_points user function now shows more information. The maximum number and oversampling factors are now also printed out for maximum user feedback. Improved the printout formatting for the count_sobol_points() frame order function. The frame order target function now passes the maximum number of Sobol' points to the relax library. The value is being passed into the lib.frame_order.*.pcs_numeric_int_*() functions, though it is not used set. Fix for the percentage calculation for the frame order count_sobol_points() function. Changed the creation of the Sobol' points in the frame order target function. For increased accuracy of the numerical PCS integration, the first 1000 points of the Sobol' sequence are now skipped to avoid any bias. For speed, the axis order of the Sobol' torsion-tilt angles has been swapped so that the numpy.swapaxes() function call is no longer required in the lib.frame_order.*.pcs_numeric_int_*() functions. Updated the frame order count_sobol_points() function to handle the swapped axis order. Huge speedup for the generation of the Sobol' sequence data in the frame order target function. The new Sobol_data class has been created and is instantiated in the module namespace as target_function.frame_order.sobol_data. This is used to store all of the Sobol' sequence associated data, including the torsion-tilt angles and all corresponding rotation matrices. When initialising the target function, if the Sobol_data container holds the data for the same model and same total number of Sobol' points, then the pre-existing data will be used rather than regenerating all the data. This can save a huge amount of time. Updated the frame order count_sobol_points() function to use the new Sobol_data container. The Sobol' sequence data generated by the target function is now located at target_functions.frame_order.sobol_data. Updated all the lib.frame_order.*.pcs_numeric_int_*() functions for the new Sobol' point algorithm. The functions now all accept the max_points argument and terminate the loop over the Sobol' points once the maximum number of points has been reached. The calls to numpy.swapaxes() have also been removed as this is now pre-performed by the target function initialisation. Changed the default oversampling factor from 100 to 1 in the frame_order.sobol_setup user function. Converted the frame order auto-analysis to use the new frame_order.sobol_setup user function design. The auto-analysis Optimisation_settings object has also been modified so that all num_int_pts arguments and internal structures have been split into the two new sobol_max_points and sobol_oversample names and objects. Fix for the rigid frame order model for the recent frame_order.sobol_setup user function changes. For this model, the number of Sobol' points normally is does not exist. This is now correctly handled. Created the sobol_setup() method for the frame order auto-analysis. This is used to correctly handle the new design of the frame_order.sobol_setup user function consistently throughout the protocol. Updated the Frame_order.test_auto_analysis system test script. This now uses the new auto-analysis Optimisation_settings object design. Updated the Frame_order.test_count_sobol_points system test. The call to the frame_order.num_int_pts user function was changed to frame_order.sobol_setup. Fixes for the Frame_order.test_count_sobol_points2 system test. The test_suite/shared_data/frame_order/axis_permutations/cam_pseudo_ellipse.bz2 relax state file has been manual edited to change the num_int_pts data pipe structure to sobol_max_points and to add the new sobol_oversample variable. Added a backwards compatibility hook for state and results files for the Sobol' sequence changes. The data pipe num_int_pts variable is now renamed to sobol_max_points when present, and the sobol_oversample variable is created and set to 1. Updates to all of the Frame_order.test_count_sobol_points_* system tests. The frame_order.sobol_setup user function is used to set a small maximum number of points (20) to allow the tests to be fast. The value of 20 is also checked for to allow the tests to pass. Renamed the cdp.used_sobol_points variable to sobol_points_used. This is created by the count_sobol_points() frame order function. The name change is to match the sobol_max_points and sobol_oversample variable names. Renamed all the Frame_order.test_num_int_pts* system tests to Frame_order.test_sobol_setup*. These system tests where for checking the operation of the old frame_order.num_int_pts user function. But this is now the frame_order.sobol_setup user function. Fix for all of the Frame_order.test_rigid_data_to_*_model system tests. The frame_order.num_int_pts user function call was changed to frame_order.sobol_setup. Updated the χ2 check in the Frame_order.test_rigid_data_to_free_rotor_model system test. This value has changed due to the first 1000 points of the Sobol' sequence being skipped. Fixes for all of the lib.frame_order.*.pcs_numeric_int_*_qrint() functions. The loop over the Sobol' points was broken. As numpy.swapaxes() has been applied to the points argument already, the loop needs to be over the second dimension of the points data structure. Updates for all of the Frame_order.test_cam_* system tests. The NUM_INT_PTS variable in the system tests scripts is now passed into the frame_order.sobol_setup user function as the max_num argument. This number has also been changed so that the tests take a reasonable amount of time. All χ2 value checks were updated. These were validated by increasing the number of integration points and watching the χ2 value of the Frame_order.test_cam_*_pcs version of the system tests head to zero. Another update for the χ2 check in the Frame_order.test_rigid_data_to_free_rotor_model system test. The previous commit used an incorrect value for the χ2. This new value is now much closer to the original. Turned down the verbosity of the update_model() frame order function. The verbosity flag is now accepted and set to zero by the get_param_names() API method and specific_analyses.frame_order.parameters.param_num() function. This removes a lot of useless printouts from many different user functions. Introduced the verbosity argument to the count_sobol_points() frame order function. This is used to turn the printouts on or off. The optimisation code now calls this function with the verbosity argument sent into the minimise.grid_search and minimise.execute user functions. Hence the printouts are suppressed for Monte Carlo simulations. Removed the axis system printout from the frame_order.pdb_model user function. This is for the geometric representation of the frame order dynamics. The axis system is printed out as the rotation matrix used for the lib.structure.geometric.generate_vector_residues() function later on anyway. The change is to simplify the printouts. Editing of the docstring of the frame_order.sobol_setup user function. Fix for the frame order system test optimisation printouts. The cdp.num_int_pts variable is now called cdp.sobol_max_points. The starting time of the axis permutation model optimisations is now output. This is in the frame order auto-analysis. This call to the time user function occurred for the normal models, so extending it to the permuted axes models makes the output more consistent. Simplified the atomic position averaging warning in the frame order analysis. Instead of throwing a warning for each spin, one warning for all spins is now given. This should make the output a lot less verbose. The frame order minimise_setup_atomic_pos() function now accepts the verbosity argument. This is used to silence the warnings in user functions such as frame_order.sobol_setup. Improvements for the frame order overfit_deselect() API method. Three changes have been made: The print statements have been converted to RelaxWarnings; The spin IDs or spin ID pairs are now stored in a list and one RelaxWarning for the missing PCS data and one for the missing RDC data is now given; And the verbose flag is now used to determine if a RelaxWarning will be given. Change to the position averaging warning in the minimise_setup_atomic_pos() frame order function. Improvements for the printout from the update_model() frame order function. A list of updated parameters is now created and everything is printed on a single line at the end. The printout is therefore much more compact. Spun out part of the frame_order.pdb_model user function into the new frame_order.simulate user function. The new user function arguments required for properly creating the pseudo-Brownian dynamics simulation would have made the frame_order.pdb_model user function too complicated. Therefore this part has been spun out into the new frame_order.simulate user function. The frame_order.simulate frontend fully describes the algorithm that will be used to simulate the dynamic content of the PCS and RDC data, and warns that not all modes of motion are visible and present. Updated the frame order auto-analysis to call the new frame_order.simulate user function. Although not implemented yet, this allows the user function to create the simulation PDB file in the future. Small fix for the new frame_order.simulate user function backend. Updated the base script for the Frame_order.test_cam_* system tests. The frame_order.simulate user function is now called directly after the frame_order.pdb_model user function. Created the backend framework for the frame_order.simulate user function. The backend specific_analyses.frame_order.uf.simulate() function performs all data checks required, prepares the output file object, assembles the frame order parameter values and pivot point, and creates a copy of the structural object object with the ensemble collapsed into a single model. All this data is then passed into the new lib.frame_order.simulation.brownian() function. This initialises all required data structures and the structural object. The main loop of the simulation is also implemented, taking snapshots at every fixed number of steps and terminating the loop once the total number of snapshots are reached. The snapshot consists of copying the original unrotated structural model and rotating it into the new position. The rotation is currently the identity matrix. The old specific_analyses.frame_order.geometric.create_distribution() stub function has been deleted. Decreased the time required for the Frame_order.test_cam_* system tests. The frame_order.simulate user function now only creates a total of 20 snapshots rather than 1000. Added new arguments to the frame order auto-analysis for the frame_order.simulate user function. These are the brownian_step_size, brownian_snapshot and brownian_total arguments which are passed directly into the frame_order.simulate user function. This gives the user more control, as well as allowing the test suite to speed up this part of the analysis. Huge speedup for the Frame_order.test_auto_analysis system test. The pseudo-Brownian dynamics simulation via the frame_order.simulate user function has been massively sped up to allow the test to be almost as fast as before. Spun out the code for shifting to the average frame order position into a new function. The old code of the create_ave_pos() of the specific_analyses.frame_order.geometric module has been shifted into the new average_position() function. This will allow the code to be reused by other parts of relax to obtain the average frame order structures. Implemented the shifting to the average position for the frame_order.simulate user function backend. This simply sends the structural object into the new average_position() function of the specific_analyses.frame_order.geometric module. Improvements for the frame_order.simulate user function. The rigid model is now skipped, the PDB file closed, and some printouts for better user feedback have been added. Changed the default PDB file name for the frame_order.simulate user function to 'simulate.pdb'. The '*.bz2' extension has been dropped so that the file is quicker to create and does not need to be decompressed for loading into molecular viewers. Created the specific_analyses.frame_order.geometric.generate_axis_system() function. This is now used by most parts of the frame order analysis to generate the full 3D eigenframe of the motions. Previously this was implemented each time the frame or major axis was required. This replicated and highly inconsistent code has been eliminated. Fix for the new specific_analyses.frame_order.geometric.generate_axis_system() function. The rotor and free rotor models were not correctly handled and the returned eigenframe was the zero matrix. Implemented the pseudo-Brownian frame order dynamics simulation for the single motion models. This uses the same logic as in the test_suite/shared_data/frame_order/cam/*/generate_distribution.py scripts which were used to generate all of the test suite data. However rather than using a random rotation matrix, a random 3D vector is used to rotate a fixed angle. And the rotation is used to rotate the current state to state i+1. The rotation for the state is decomposed into torsion-tilt angles once shifted into the motional eigenframe, the violations checked for as the state shifted to the boundary, then the new state reconstructed from the corrected torsion-tilt angles, and then it is shifted from the motional eigenframe to the PDB frame. Shifted the specific_analyses.frame_order.variables module into the lib.frame_order package. This is both to minimise circular dependencies, as previously the specific_analyses.frame_order modules import from target_functions.frame_order and vice-versa, and to allow the relax library functions to have access to these variables. Implemented the frame_order.simulate user function backend for the double rotor frame order model. This involved extending the algorithm to loop over N states, where N=2 for the double rotor and N=1 for all other models. To handle the rotations being about the x and y-axes, an axis permutation algorithm is used to shift these axes to z prior to decomposing to the torsion-tilt angles. The reverse permutation is used to shift the axes back after correcting for being outside of the allowed angles. Fixes for the specific_analyses.frame_order.geometric.average_position() function. The recent trunk changes with the structural object Internal_selection class required a change in this function. Updated the lib.frame_order.simulation.brownian() function. This now uses the internal structural object selection object logic - the selection() method is called to obtain the Internal_selection object, and this is then passed into the rotation() method. The quad_int argument for the frame order target function class now defaults to False. This is so that quasi-random Sobol' numerical integration will be used by default. The cdp.quad_int flag is now passed into the target function for the frame order calculate() method. This is for the minimise.calculate user function backend. Fixes for the missing cdp.quad_int flag. If the cdp.quad_int flag is missing, this is now set to False before setting up the target function class. The previous behaviour was that the frame_order.quad_int user function must be called prior to optimisation. Now it is optional for turning this flag on and off. The RDC only optimisation now defaults to the *_qrint() frame order target functions. This restores the earlier behaviour prior to the restoration of the SciPy quadratic integration. Clean up for the frame order target function aliasing. The Scipy quadratic integration and the quasi-random Sobol' integration target functions are now aliased using the getattr() Python method to programmatically choose one or the other. The rigid model has been removed from the list as it is not a numeric model, and the func_double_rotor() target function has been renamed to func_double_rotor_qrint() to make it consistent with the naming of the other target functions. Renaming of all the frame order target functions and PCS integration functions. For consistency, all quasi-random Sobol' integration functions now use the 'qr_int' tag whereas the SciPy quadratic integration functions use the 'quad_int' tag. This is not only in the target function names but also the PCS integration functions in lib.frame_order. Duplicated all Frame_order.test_cam_* system tests for testing the SciPy quadratic integration. The Frame_order.test_cam_* system tests have all been renamed to Frame_order.test_cam_qr_int_*. These have been duplicated and renamed to Frame_order.test_cam_quad_int_*. The flag() system test method has been extended to include the quad_int flag which is then stored in the status object and used in the base CaM frame order system test script to activate the frame_order.quad_int user function. Activated the quad_int flag for a number of the Frame_order.test_cam_quad_int_* system tests. The quad_int argument for the flags() test suite method had been missed for a few of these tests. Updated the χ2 check in the Frame_order.test_cam_qr_int_pseudo_ellipse_free_rotor_rdc system test. This test is not normally run as it blacklisted and duplicates the coverage of other tests. However its chi-squared value check had not been updated for a while and hence the test fails when explicitly run. The Sobol' point counting is now turned off for the frame order optimisation functions if none exist. If the cdp.quad_int flag is set, then there will be no Sobol' points to count. This count_sobol_point() user feedback function will therefore not be called by the minimise.calculate, minimise.grid_search and minimise.execute user functions. Turned off optimisation for all of the Frame_order.test_cam_quad_int_* system tests. The SciPy quadratic integration is far too slow to be used in the test suite. The simple call to the minimise.calculate user function is sufficient for checking these target functions. Updated all of the Scipy quadratic integration frame order target functions. A number of the data structures in the target function class have been redesigned since these target functions were deleted. All of the func_*_quad_int*() target functions have been updated for these changes. Updated all of the χ2 value checks for the Frame_order.test_cam_quad_int_* system tests. This is only for those tests which use PCS data - the RDC only test χ2 values are the same as in the Frame_order.test_cam_qr_int_* system tests. In all cases, the χ2 value is lower for the more accurate SciPy quadratic integration as compared to the quasi-random Sobol' integration, as expected. Implemented the SciPy quadratic integration target function for the double rotor frame order model. This simply follows from what all the other quadratic integration target functions and lib.frame_order module functions do. Changed the χ2 value checks in the Frame_order.test_cam_quad_int_double_rotor* system tests. These were the values for the quasi-random Sobol' integration and needed updating for the SciPy quadratic integration. Removed the skip_tests argument for the Frame_order system tests __init__() method. This argument, which was used to manually turn on or off the blacklisted tests, is no longer needed due to the new --no-skip relax command line flag which will enable all blacklisted tests. The [http://www.nmr-relax.com/api/4.0/auto_analyses.frame_order-module.html frame order auto-analysis Optimisation_settings object now supports the quad_int flag. This is for activating the SciPy quadratic integration. It is accepted as an argument for the add_grid() and add_min() methods, and it returned by the new get_grid_quad_int() and get_min_quad_int() methods. Added the ability to specify a pre-run directory in the frame order auto-analysis. This will be used for refinement purposes. If the new pre_run_dir argument, modelled on the relaxation dispersion auto-analysis, is supplied then results files will be loaded from this directory and the base data pipe copying and PCS subset optimisation steps will be skipped. The model nesting algorithm is also deactivated. Activated the SciPy quadratic integration in the frame order auto-analysis. If the Optimisation_settings object has been set up with the quad_int flag, then the auto-analysis will skip the sobol_setup() method and instead directly call the frame_order.quad_int user function. Optimisation will then use the SciPy quadratic integration rather than the quasi-random Sobol' integration. Improvements for the usage of the frame_order.quad_int user function in the auto-analysis. The frame_order.quad_int user function is now called even when the Optimisation_settings object quad_int flag is False. This allows for switching between the SciPy quadratic integration and the quasi-random Sobol' integration, as the SciPy quadratic integration can now be turned off. Additions to the frame order auto-analysis documentation. Incorporated the contents of the summarise.py script into the frame order auto-analysis module. This has been converted into the summarise() function which will generate a results summary table as the analysis is still running. Improved logic in the auto_analyses.frame_order.summarise() function. The model names, directories and titles are now being auto-generated from the full list of frame order models in lib.frame_order.variables.MODEL_LIST. To create a common mechanism for determining the model directory name, the Frame_order_analysis.model_directory() method has been converted into a module function. The frame order auto-analysis now calls the summarise() function at the end to create a summary table. Shifted the final state saving in the frame order auto-analysis to be within the safety of the try block. Turned off the final state saving in the Frame_order.test_auto_analysis system test. This almost halves the time required for the test. A private class variable _final_state has been added to the auto_analyses.frame_order.Frame_order_analysis class which when False will cause the state saving step to be skipped. The summarise() function call is now after saving the final state in the frame order auto-analysis. This is needed because the summarise() function will create a new set of data pipes, loading the results which already exist under a different pipe name in the relax data store. Otherwise the final state file is twice as big as it should be. Incorporated the contents of count_sobol_points.py into the frame order auto-analysis module. The analysis script has been converted into the count_sobol_points() function which will generate a summary table of the number of quasi-random Sobol' points used for the PCS numerical integration. The frame order auto-analysis now calls the count_sobol_points() function at the end. This is to automatically create the Sobol' point summary table. Fixes for the auto_analyses.frame_order.summarise() function. If the count_sobol_points() function is called followed by summarise(), a RelaxError will be raised as the data pipe already exists. The summarise() function has been modified to switch to the data pipe if it already exists. Expanded the frame order auto-analysis documentation. This adds a description for the summarise() and count_sobol_points() functions. Elimination of most of the Frame_order.fixme_test_* system tests and associated data. These tests are from a very early stage of the development of the frame order theory back when the base data was the full and reduced alignment tensors for the each domain calculated from the RDC data. They do not fit into the current analysis where the base data is the RDCs and PCSs for the moving domain. There is no point upgrading the tests as it will be far too much effort and it will only duplicate the coverage of the Frame_order.test_cam_* system tests. Renamed the Frame_order.fixme_test_opendx_map system test to Frame_order.test_opendx_map to activate it. Upgraded the Frame_order.test_opendx_map system test. To upgrade from the ancient design to the current design so that the test is functional and relevant, this now uses the same setup as the Frame_order.test_cam_qr_int_rigid system test. Instead of performing optimisation, the test calls the dx.map user function. Fix for the frame order specific API calculate() method. This was caught by the Frame_order.test_opendx_map system test. The scaling matrix was not being specified by the dx.map user function backend and this was causing the method to fail. Instead of passing the non-existent scaling matrix into the target function, the argument is simply ignored. The scaling matrix has no effect on the minimise.calculate user function so it is not necessary. The verbosity flag is now being respected by the frame order specific API calculate() method. This silences the method when executing the dx.map user function. The χ2 value printout is suppressed and the verbosity argument is being sent into the frame order count_sobol_points() function. Added a section printout to the frame order auto-analysis when summary tables are created. The frame_order.simulate user function now defaults to creating a gzipped PDB file. This is to save room, and because most molecular viewers will automatically read gzipped PDB files. Fix for the change of the pipe_control.pipes.test() function to check_pipe(). Small change in the title of the summary table of the frame order auto-analysis. 'Order parameters' has been replaced by 'Cone half angles' to clarify what the values really are. Fix for the frame order optimisation target setup printouts. The 'Numerical integration: ' printout was fixed to 'Quasi-random Sobol' sequence'. This now changes to 'SciPy quadratic integration' if cdp.quad_int is set. The text 'PCS' has also been added for clarification. Removed the call to the frame_order.simulate user function for the rigid model in the auto-analysis. There is no motion to simulate in the rigid model, so the frame_order.simulate user function has no use. Improvements, fixes, and expansion of the results and data visualisation file creation. This is for the frame order auto-analysis. The visualisation() method has been renamed to results_output() and its scope expanded. The function previously only called the frame_order.pdb_model and frame_order.simulate user functions for creating PDB representations of the frame order motions and performing a pseudo-Brownian frame order dynamics simulate. This has been extended to also call the results.write user function for outputting results files and the rdc.corr_plot and pcs.corr_plot for generating correlation plots of the measured vs. back-calculated data. All parts of the auto-analysis were output files are required now call this method. This ensures that all output files are always created, and are placed into the correct directories. Improvements for the sectioning printouts for the frame order auto-analysis. The sections now use the lib.text.formatting subtitle() and subsubtitle() functions to distinguish them from the output of all the user functions, which use the section(), subsection() and subsubsection() functions. New sectioning printouts have been added for clarity. Possible fixes for the frame order auto-analysis. This is just in case a user decides to not perform the optimisation starting with a PCS subset. In this case, the analysis will now execute correctly. Improvements to the summary table for the frame order auto-analysis. The rotor and free rotor model motional eigenframe parameter axis_alpha is now being converted into spherical angles and reported in the table. This allows the motional eigenframe of all models to be easily compared in the table. Created a directory and base PDB system for testing out the PCS information content. The base PDB system consists of Ad Bax's CaM domain structures superimposed onto the open CaM structure, the N-domain CoM shifted to the origin, and the C-domain CoM shifted to the z-axis. Modified the PCS content testing base system. The paramagnetic centre is now shifted to the origin, as this is the real centre of the PCS physics. Intermediate optimisation results are now stored by the frame order auto-analysis. The results from each minimise.grid_search and minimise.execute user function call are now stored in specially named directories located in the 'intermediate_results' directory, which itself is located in the auto-analysis results_dir directory. This allows intermediate results to be more easily analysed later on, which can be useful for optimising the optimisation steps. These directories can also be used for the pre_run_dir auto-analysis argument for subsequent refinements from earlier steps in the optimisation. The results stored include everything from the results_output() method and the count_sobol_points() and summarise() functions. To allow this to work, the auto-analysis functions count_sobol_points() and summarise() required modification. Results files are now always loaded into a temporary data pipe, rather switching to the corresponding pipe, and the temporary data pipe is deleted after the data has been extracted. The original data pipe name is also stored and a switch back to that pipe occurs at the end of each function. The simulation is now turned of for intermediate results in the frame order auto-analysis. The intermediate results are only for checking, so for these the full pseudo-Brownian dynamics simulations are not required. The simulation flag has been introduced into the results_output() method of the auto-analysis to control this. The splitting of the rigid model grid search into rotation and translation parts is now optional. In the frame order auto-analysis, the rigid_grid_split argument has been introduced. The alternating algorithm of performing a grid search over the rotational space followed by translation is now optional and turned off by default. The reason is because the global minimum is sometimes missed with this shortcut algorithm. Speedup of the Frame_order.test_auto_analysis system test. The splitting of the rigid model grid search into rotation and translation parts has been reactivated. Created the Optimisation.has_grid() method for the frame order auto-analysis. This is used to test if the optimisation settings object has a grid search defined. The grid search can now be skipped for the rigid model in the frame order auto-analysis. If the input 3D structures are close to the real solution, the grid search over the translational and rotation parameters of the rigid model could be skipped. This speeds up the analysis and can help find the real solution in problematic cases. The intermediate results storing can now be turned off in the frame order auto-analysis. The new store_intermediate Boolean argument has been added to the analysis to allow the storage of these results to be turned on or off. The intermediate results are no longer stored in the Frame_order.test_auto_analysis system test. This drops the test timing on one system from ~190 seconds to ~50 seconds. The compression level for results files can now be set in the frame order auto-analysis. This is via the new argument results_compress_type, which is used to set the compress_type argument of the results.write user function. The results reading parts of the auto-analysis have been updated to allow uncompressed, bzip2 compressed, and gzip compressed files to be handled. Added a printout of the frame order model in the target function setup function. This is printed out when the minimise.calculate, minimise.grid_search, or minimise.execute user functions are called, and is for better feedback, especially in the auto-analysis where the repetitive optimisations can be confusing. Updated the frame order analysis for the structure.load_spins user function changes. The minimise_setup_atomic_pos() function of the specific_analyses.frame_order.optimisation module now handles the mixed type spin.pos variable correctly. The data pipe containing a PCS subset is now optional in the frame order auto-analysis. This is for systems which have so little data that a subset makes no sense. Redesigned the optimisation steps for the frame order auto-analysis. The code has been significantly simplified as the optimisation for the PCS subset and full data set was the same. The code duplication has been eliminated by combining it into the new optimisation() method. The check for the PCS subset has also been expanded so that it is skipped if the subset data pipe is not supplied, even if an optimisation object for the subset has been (this should prevent strange errors when the auto-analysis is incorrectly used). A side effect of this code merger is that the zooming grid search has now been activated for the full PCS data set. This is of great benefit when a PCS subset is not being used. The minimise.execute user function skip_preset flag is now False in the frame order auto-analysis. This is for the main model optimisation. Without this flag set, the grid search for the pivot point position for the rotor model was being skipped at the first zoom level. The pivot point can now be excluded from the grid search in the frame order auto-analysis. If the initial pivot point is known to be reasonable, then it may be possible to skip it in the grid search for the rotor frame order model. This can lead to a speedup of the analysis and can help with stability. The pivot_search argument has been added to the auto-analysis Optimisation.add_grid() method to enable this. The get_grid_pivot_search() method has also been added to allow the auto-analysis to query this and turn it off if desired. Updated the description of the frame_order.permute_axes user function. This now includes the isotopic cone. Replaced the table in the frame_order.permute_axes user function. The original table was an old and incorrect version. This has been replaced by the correct permutation table. Added some old relax scripts for both simulating and predicting the frame order matrix elements. These were used for the initial implementation of the pseudo-ellipse frame order model back in July 2010. The scripts will be extended for all frame order models. The simulated values could then be used in unit tests of the frame order matrix code in lib.frame_order. Updated the frame_order_simulate.py script for simulating frame order matrix elements. The MODEL variable has been added in preparation for supporting all model types, and this is now added to the file name. The Grace header is now also being automatically generated. Improvements for the Grace files produced by the frame_order_simulate.py script. The model name is now set as a variable and is used for the subheading. Updated the frame_order_solution.py script for directly calculating the frame order matrix elements. The MODEL variable has been added in preparation for supporting all model types, and this is now added to the file name. The Grace header is now also being automatically generated and this matches that for the frame_order_simulation.py script. Zero values can now be handled in the pseudo-ellipse 1st degree frame order matrix function. This is in lib.frame_order.pseudo_ellipse.compile_1st_matrix_pseudo_ellipse(). Removed some unused code in the pseudo-ellipse 2nd degree frame order matrix function. This is the compile_2nd_matrix_pseudo_ellipse() function in the lib.frame_order.pseudo_ellipse module. The change should make the RDC part of the frame order analysis for the pseudo-ellipse model slightly faster. Modified the rotate_daeg() function as this is independent of the degree of the frame order matrix. This is the lib.frame_order.matrix_ops.rotate_daeg() function. Fix for the compile_1st_matrix_pseudo_ellipse() function. This function of the lib.frame_order.pseudo_ellipse module now can rotate the 1st degree frame order matrix out of its eigenframe and into the PDB frame. Created an executable Python script for mass converting the frame order matrix Grace graphs. The script converts the *.agr files to EPS and PNG files. Modified the frame order matrix Grace graph to EPS/PNG format conversion script. The binary being called is now 'grace' rather than 'xmgrace'. This allows different Grace versions to be used. Modified the frame order matrix Grace graph to EPS/PNG format conversion script. Grace is now used to create a PostScript file and then the ps2eps program is called to convert to EPS. This produces much better EPS files for inclusion into LaTeX documents. Redesign of the frame_order_solution.py script for calculating the frame order matrix elements. This script now loops over all models, all motional frame orientations, and all order parameters to generate the Grace graphs of all 1st and 2nd degree frame order matrix elements. Therefore the script only needs to be executed once. The script also now calculates a point at zero (slightly shifted to 0.01 to avoid artifacts). Added all of the Grace graphs produced by the frame_order_solution.py script. These are the graphs of the 1st and 2nd degree frame order matrix elements, calculated using the functions in lib.frame_order. Updated frame_order_simulate.py to be much faster in simulating the frame order matrix elements. The script also matches the Grace file output of the frame_order_solution.py script. The inside() method has been renamed for the pseudo-ellipse and the infrastructure for adding support for the other frame order models has been added. By shifting calculations outside of the loops, the script is now many orders of magnitude faster. Implemented the compile_1st_matrix_rotor() function. This is for the lib.frame_order.rotor module. The function will calculate the 1st degree in-frame frame order matrix for the rotor model. Created the Grace graphs for the rotor model 1st degree frame order matrix elements. These are the values calculated directly from the lib.frame_order modules. The graphs were previously all zeros. Implemented the compile_1st_matrix_free_rotor() function. This is for the lib.frame_order.free_rotor module. The function will calculate the 1st degree in-frame frame order matrix for the free rotor model. Created the Grace graphs for the free rotor model 1st degree frame order matrix elements. These are the values calculated directly from the lib.frame_order modules. The graphs were previously all zeros. Implemented the compile_1st_matrix_iso_cone() function. This is for the lib.frame_order.iso_cone module. The function will calculate the 1st degree in-frame frame order matrix for the isotropic cone model. Created the Grace graphs for the isotropic cone model 1st degree frame order matrix elements. These are the values calculated directly from the lib.frame_order modules. The graphs were previously all zeros. Implemented the compile_1st_matrix_iso_cone_torsionless() function. This is for the lib.frame_order.iso_cone_torsionless module. The function will calculate the 1st degree in-frame frame order matrix for the torsionless isotropic cone model. Created the Grace graphs for the torsionless isotropic cone 1st degree frame order matrix elements. These are the values calculated directly from the lib.frame_order modules. The graphs were previously all zeros. Implemented the compile_1st_matrix_iso_cone_free_rotor() function. This is for the lib.frame_order.iso_cone_free_rotor module. The function will calculate the 1st degree in-frame frame order matrix for the free rotor isotropic cone model. Created the Grace graphs for the free rotor isotropic cone 1st degree frame order matrix elements. These are the values calculated directly from the lib.frame_order modules. The graphs were previously all zeros. Docstring fixes for the new compile_1st_matrix_iso_cone() function. A minor speedup for the frame_order_simulate.py script. The angles are now being calculated at the very start prior to the main loop, removing repetitive calculations. The frame_order_simulate.py script now uses lib.text.progress.progress_meter(). This script for simulating the frame order matrix elements now uses the standard progress meter in relax to simplify the script. This should also speed up the calculations as the progress printouts were slowing down the calculations. Simulation of the pseudo-ellipse frame order matrix elements. This is for a simulation of 1,000,000 states for each angle increment, and includes in-frame and out-of-frame and varying of θ X, Y, and Z. The resultant Grace graphs have been added to the repository. The frame order matrix element simulation script now uses the Kronecker outer product. This allows the frame order matrix to be in the same notation as that used internally in relax. It will cause the colours of the Sijkl_* curves to match between the simulation and solution scripts. Added the rotor model to the frame order matrix element simulation script. The generated in-frame and out-of-frame Grace graphs containing the matrix values for 1,000,000 simulation values have been added to the repository. The script was modified so that the rotation is generated by special rotation_*() methods which are aliased depending on the model. Added the free rotor model to the frame order matrix element simulation script. The generated in-frame and out-of-frame Grace graphs containing the matrix values for 1,000,000 simulation values have been added to the repository. The inside_free_rotor() method has been added to always return True for the rotation generated by rotation_z_axis(). Simplifications and fixes for the 1st degree frame order matrix calculation for the pseudo-ellipse. The compile_1st_matrix_pseudo_ellipse() function of the lib.frame_order.pseudo_ellipse module has been significantly simplified by shifting a lot of maths outside of the quadratic integration. Updated all the calculated 1st degree frame order matrix graphs for the pseudo-ellipse. The changes are due to the fixes in the lib.frame_order.pseudo_ellipse module. Simplifications for all of the torsionless pseudo-ellipse frame order matrix equations. Implemented the compile_1st_matrix_pseudo_ellipse_torsionless() function. This is for the lib.frame_order.pseudo_ellipse_torsionless module. The function will calculate the 1st degree in-frame frame order matrix for the torsionless pseudo-ellipse model. Created the Grace graphs for the torsionless pseudo-ellipse model 1st degree frame order matrix. These are the values calculated directly from the lib.frame_order modules. The graphs were previously all zeros. Added the isotropic cone model to the frame order matrix element simulation script. The generated in-frame and out-of-frame Grace graphs for the torsion angle cone_sigma_max, containing the matrix values for 1,000,000 simulation values have been added to the repository. The inside_iso_cone() method has been created to check for the θx and θz angle violations from the rotation_hypersphere() method. Simplifications for the inside_*() methods of the frame order matrix element simulation script. The limit() method is now called only once outside of these methods and the maximum cone half-angles passed into the inside_*() methods. Although only slightly faster, this is mainly to simplify the code. Alphabetical ordering of methods in the frame order matrix element simulation script. Simplification of some of the pseudo-ellipse 2nd degree frame order matrix equations. More simplifications of the pseudo-ellipse 2nd degree frame order matrix equations. Integer to float conversions in part_int_daeg2_pseudo_ellipse_13(). This avoid integer to float conversion during execution, saving a little time for the pseudo-ellipse 2nd degree frame order matrix compilation. Removal of many repetitive calculations in the pseudo-ellipse 2nd degree frame order matrix equations. Simplifications of pseudo-ellipse 1st degree frame order matrix functions. The xx, yy, and zz have been renamed to 00, 11, and 22 for consistency. And all sigma_max arguments have been dropped as they are not used. Small numerical changes for the pseudo-ellipse 2nd degree frame order matrix graphs. These are only for the first point close to zero and the changes are minimal, caused by the recent simplifications of the code. Created the Grace graphs for the free rotor pseudo-ellipse model 1st degree frame order matrix. These are the values calculated directly from the lib.frame_order modules. The graphs were previously all zeros. Implemented the compile_1st_matrix_pseudo_ellipse_free_rotor() function. This is for the lib.frame_order.pseudo_ellipse_free_rotor module. The function will calculate the 1st degree in-frame frame order matrix for the free_rotor pseudo-ellipse model. Speedups and simplifications of the free rotor pseudo-ellipse 2nd degree frame order matrix equations. Added the torsionless isotropic cone model to the frame order matrix element simulation script. Implemented the compile_1st_matrix_double_rotor() function. This is for the lib.frame_order.double_rotor module. The function will calculate the 1st degree frame order matrix for the double_rotor model. Created the Grace graphs for the double rotor model 1st degree frame order matrix. These are the values calculated directly from the lib.frame_order modules. The graphs were previously all zeros. Recreated all of the simulated pseudo-ellipse frame order matrix element graphs. These are now in the Kronecker product notation so that they will match the graphs calculated using the relax lib.frame_order.pseudo_ellipse module. Fix for the pseudo-ellipse 1st degree frame order matrix ᛞ22 element. Updated all of the pseudo-ellipse 1st degree frame order matrix graphs for the recent fix. Converted the Sobol' rotation matrices to float32 in the frame order target function. This is to conserve huge amounts of memory to allow for more Sobol' points to be used. For example for the models which use 3D Sobol' points (isotropic cone and pseudo-ellipse), a maximum of 50000 Sobol' points requires 50000000 to be created, using about 15 Gb of RAM. A few Frame_order system test updates for the float64 to float32 memory saving changes. The chi-squared value of 3 tests was slightly different. Bug fix for the activation of quadratic integration in the frame order auto-analysis. The calls to the frame_order.quad_int user function in the optimisation() method did not supply an argument so the user function was defaulting to False rather than the True value required. The frame order auto-analysis summary functions are now more robust. If the data pipe already exists for some reason, it is deleted prior to the new one being created. Changed the frame_order.quad_int user function argument default to True. This means that calling the user function without arguments will activate the quadratic integration rather than turning it off. Added the isotropic cone model frame order matrix simulation graphs for the cone opening angle θx. Created and added all of the torsionless isotropic cone simulated frame order matrix element graphs. Added the free rotor isotropic cone model to the frame order matrix element simulation script. The generated Grace graphs containing the matrix values for 1,000,000 simulation values have been added to the repository. The self.torsion_check variable has been created to allow the inside_iso_cone() method to skip the torsion angle check when its value is False. Added the torsionless pseudo-ellipse model to the frame order matrix element simulation script. The generated Grace graphs containing the matrix values for 1,000,000 simulation values have been added to the repository. The rotations are generated by the rotation_hypersphere_torsionless() method and the angle violations checked using the inside_pseudo_ellipse() method. Bug fix for the torsionless pseudo-ellipse 1st degree frame order matrix. The 11 element was of the wrong sign. Fixes for the torsionless pseudo-ellipse 1st degree frame order matrix element graphs. Added the free rotor pseudo-ellipse model to the frame order matrix element simulation script. This only required the self.torsion_check variable to be set to False. The model uses the inside_pseudo_ellipse() and rotation_hypersphere() methods. Fixes for free rotor isotropic cone 1st degree frame order matrix graphs calculated using relax. The 1st degree function accepts the cone opening angle θ rather than the order parameter S. Added the frame order matrix element graphs for the in-frame free rotor pseudo-ellipse model. Added the frame order matrix element graphs for the out-of-frame free rotor pseudo-ellipse model. Added support for the double rotor model to the frame order matrix element simulation script. The double rotation is constructed in the new rotation_double_xy_axes() method, and the checks for the violation of the two torsion angles in the inside_double_rotor() method. In the main loop, the θ, φ and σ angles correspond to sigma1, sigma2, and nothing. Fixes for all of the calculated double rotor model frame order matrix graphs. The X and Y angles were mixed up. The first torsion half-angle sigma1 corresponds to a y-axis rotation and the second sigma2 corresponds to a x-axis rotation. Added the frame order matrix element graphs for the double rotor model. A divide by zero fix for the torsionless pseudo-ellipse. This is in the compile_2nd_matrix_pseudo_ellipse_torsionless() relax library function. A divide by zero fix for the free rotor pseudo-ellipse. This is in the compile_2nd_matrix_pseudo_ellipse_free_rotor() relax library function. The 1st angle for the calculated frame order matrix graphs is 0 for all non pseudo-ellipse models. This is for the frame_order_solution.py script. Only the pseudo-ellipse models where numerical integration is required fail for the angle of 0.0. Therefore the changing of the first angle from 0.0 to 0.01 only occurs for the pseudo-ellipse models. All graphs have been updated. The 1st pseudo-ellipse torsion angle value in the frame order matrix graphs is now 0.0. Only the cone opening angles set to 0.0 cause a failure in the pseudo-ellipse models, so the torsion angle is now allowed to start at exactly zero. Clean up of the frame order matrix element simulation script. Redesign of the free rotor isotropic cone frame order model - the order parameter has been replaced. From the frame order matrix element graphs in test_suite/shared_data/frame_order/sim_vs_pred_matrix, specifically Sijkl_iso_cone_free_rotor_in_frame_theta_x_calc.agr, Sijkl_iso_cone_free_rotor_axis2_1_3_theta_x_calc.agr, and Sijkl_iso_cone_free_rotor_out_of_frame_theta_x_calc.agr, it is clear that the symmetry of the order parameter after 120 degrees causes the 2nd degree frame order matrix to be incorrectly estimated. Therefore the S1 order parameter has been replaced with the original cone opening angle cone_theta. All parts of relax have been updated for this large conversion. Updated the frame order matrix element graphs for the free rotor isotropic cone fixes. The cone S1 parameter has been converted back to the original cone θ opening half-angle, allowing the 2nd degree frame order matrix elements to be properly calculated for all motions. Eliminated the lib.frame_order.iso_cone.populate_*() functions. The populate_1st_eigenframe_iso_cone() function was unused and incorrect, so it was deleted. The contents of the populate_2nd_eigenframe_iso_cone() function have been shifted compile_2nd_matrix_iso_cone() as a separate function is unnecessary. This now matches all the other lib.frame_order modules. Bug fix for the frame_order.simulate user function. The incorrect model number was being specified and hence the simulation was not starting from the optimised average domain position but rather the arbitrary position of the original structure. Manual Python 3 fixes for the dict.key() function which returns a list or iterator in Python 2 or 3. This matches r26519 in trunk. Python 3 fixes via 2to3 - the "while 1" construct has been replaces with "while True". The command used was: 2to3 -j 4 -w -f idioms . Python 3 fixes via 2to3 - the spacing around commas has been fixed. The command used was: 2to3 -j 4 -w -f ws_comma . Python 3 fixes via 2to3 - the xrange() function has been replaced by range(). The command used was: 2to3 -j 4 -w -f xrange . Started to create the Frame_order.test_pdb_model_rotor system test. This will be used to check that the PDB representations of the frame order motions are correct. Modified the frame_order.pdb_model user function backend to handle missing structural data. The create_ave_pos() function of the specific_analyses.frame_order.geometric module now checks that cdp.structure exists, and if not a warning is given and the PDB file creating is skipped. Fixes for the frame_order.pdb_model user function backend for when no data is present. The pipe_centre_of_mass() function of pipe_control.structure.mass module is now called with the missing_error flag set to False so that the PDB generation can continue with the CoM set to [0, 0, 0]. The geometric representation part of the frame_order.pdb_model user function now checks parameters. This calls the specific_analyses.frame_order.checks.check_parameters Check object to make sure that all necessary parameters for the model exist. Completed the Frame_order.test_pdb_model_rotor system test. This now sets the rotor axis to the z-axis (with a printout to be sure), sets the torsion angle to zero for simplicity, creates a new data pipe and loads the PDB representation file, then checks all of the key atom coordinates. Fixes for the unit tests of the lib.frame_order.matrix_ops module for the free rotor isotropic cone. The S1 order parameter has been eliminated due to angles > π/2.0 causing the frame order matrix to be incorrectly predicted. Therefore all unit tests have been converted to use the cone opening angle θ instead. In addition, the test_compile_2nd_matrix_iso_cone_free_rotor_disorder had been modified to pass with the incorrect frame order matrix by comparing to the half cone frame order matrix rather than the identity frame order matrix. Fix for inverted axes in the new Frame_order.test_pdb_model_rotor system test. Huge bug fix for the frame_order.pdb_model user function - the single axis direction was incorrect. In the PDB representation of the frame order motion for the rotor and isotropic cone models (rotor, free rotor, isotropic cone, free rotor isotropic cone, and torsionless isotropic cone), the X and Z axes were swapped. This is because the eigenframe of the motion was being incorrectly constructed via the lib.geometry.rotations.two_vect_to_R() function. For better control, the specific_analyses.frame_order.geometric.frame_from_axis() function has been created. This constructs a full motional eigenframe from the Z-axis. The problem was detected via the new Frame_order.test_pdb_model_rotor system test. Size fix for the rotor representation from the frame_order.pdb_model user function. The size problem was detected via the Frame_order.test_pdb_model_rotor system test. The rotors in the PDB representation were all fixed in size, and ignored the 'size' argument of the frame_order.pdb_model user function. The size argument is now passed into the add_rotors() function of the specific_analyses.frame_order.geometric module and passed on to the rotor() function of the lib.structure.represent.rotor module. Created the Frame_order.test_pdb_model_rotor2 system test to check for an offset pivot. The pivot is set to [1, 0, 1] so that the rotor axis is tilted -45 degrees in the xz-plane. And the size of the geometric object is set to 100 Angstrom for better testing of the sizes of the elements. Simplification of the Frame_order.test_pdb_model_rotor system test. The size is now programatically handled. Created the Frame_order.test_pdb_model_iso_cone system test. This is for checking the PDB representation of the isotropic cone frame order model created by the frame_order.pdb_model user function. It checks both A and B representations. Fix for the cone sized created by the frame_order.pdb_model user function. The 'size' argument was not being used at all for the cone size. It is now passed into the lib.structure.represent.cone.cone() function as the 'scale' argument. Small fix for the Frame_order.test_pdb_model_iso_cone system test for the 'B' representation. Fix for the representation label positions created by the frame_order.pdb_model user function. The 'size' argument was not being used at all for the representation title atoms. It is now passed into the add_titles() function as the displacement argument + 10 Angstrom. Printout fix for the axis in the Frame_order.test_pdb_model_iso_cone system test. Created the Frame_order.test_pdb_model_iso_cone_xz_plane_tilt system test. This checks the PDB file from the frame_order.pdb_model user function for the isotropic cone model with a xz-plane tilt. Renamed all of the Frame_order.test_pdb_model_* system tests to be more descriptive. Improvements for all of the Frame_order.test_pdb_model_* system tests. The rotate_from_Z() method has been introduced to simplify the determination of the 3D coordinates expected for the PDB file. This will allow for more advanced testing of the PDB for the cone models. Fixes for the printouts from the Frame_order.test_pdb_model_rotor_* system tests. Alphabetical ordering of the Frame_order system test methods. Fixes for all of the Frame_order system tests - the temporary directories are now being deleted. The system test base class tearDown() method is now being called to properly clean up after the tests. Created the Frame_order.test_pdb_model_pseudo_ellipse_z_axis system test. This demonstrates the correct atom coordinates in the PDB file created by the frame_order.pdb_model user function for the pseudo-ellipse model along the z-axis. Fixes for the checks in the Frame_order.test_pdb_model_* system tests. Atomic positions are now checked with self.assertAlmostEqual() to 3 places, and the residue and atom names and numbers are checked with self.assertEqual(). Created the Frame_order.test_pdb_model_pseudo_ellipse_xz_plane_tilt system test. This checks the PDB file created by the frame_order.pdb_model user function for the pseudo-ellipse model with a xz-plane tilt. To properly construct the coordinates, the rotate_from_Z() method was modified to accept a rotation matrix argument to allow the geometric shape to be rotated. Modified the Frame_order.test_pdb_model_iso_cone_xz_plane_tilt system test to have a cone angle. The cone opening half-angle was previously 0.0. The test now checks the geometric object in the PDB file for a cone opening half-angle of 2.0. Modified the Frame_order.test_pdb_model_iso_cone_z_axis system test to have a cone angle. The cone opening half-angle was previously 0.0. The test now checks the geometric object in the PDB file for a cone opening half-angle of 2.0. Created two new system tests for the free rotor PDB representation file. This is the file from the frame_order.pdb_model user function. The two new unit tests are Frame_order.test_pdb_model_free_rotor_z_axis and Frame_order.test_pdb_model_free_rotor_xz_plane_tilt. Created two new frame order system tests for the free rotor isotropic cone PDB representation file. This is the two PDB files from the frame_order.pdb_model user function. The two new system tests are Frame_order.test_pdb_model_iso_cone_free_rotor_z_axis and Frame_order.test_pdb_model_iso_cone_free_rotor_xz_plane_tilt. Created two new frame order system tests for the torsionless isotropic cone PDB representation file. This is the two PDB files from the frame_order.pdb_model user function. The two new system tests are Frame_order.test_pdb_model_iso_cone_torsionless_z_axis and Frame_order.test_pdb_model_iso_cone_torsionless_xz_plane_tilt. Created two new frame order system tests for the free rotor pseudo-ellipse PDB representation file. This is the two PDB files from the frame_order.pdb_model user function. The two new system tests are Frame_order.test_pdb_model_pseudo_ellipse_free_rotor_z_axis and Frame_order.test_pdb_model_pseudo_ellipse_free_rotor_xz_plane_tilt. Created two new frame order system tests for the torsionless pseudo-ellipse PDB representation file. This is the two PDB files from the frame_order.pdb_model user function. The two new system tests are Frame_order.test_pdb_model_pseudo_ellipse_torsionless_z_axis and Frame_order.test_pdb_model_pseudo_ellipse_torsionless_xz_plane_tilt. Created two new frame order system tests for the double rotor PDB representation file. This is the two PDB files from the frame_order.pdb_model user function. The two new system tests are Frame_order.test_pdb_model_double_rotor_z_axis and Frame_order.test_pdb_model_double_rotor_xz_plane_tilt. Added relax scripts and PDB files which match the Frame_order.test_test_pdb_model_* system tests. These were used to construct and visually check the tests in a molecular viewer. These could be a useful reference, so have been added to the repository. Simplified all of the Frame_order.test_pdb_model_* system tests. The atom, residue and 3D coordinate checking in all these methods has been shifted into the common check_pdb_model_representation() method. This dramatically decreases the amount of code in the system test file. Simplification for all of the Frame_order.test_pdb_model_* system tests. The model setup in all of these tests has been merged into the common setup_model() method. This not only removes a large quantity of repetitive code, but the new method can also be used for constructing future tests, for example for checking the frame_order.simulate user function. Created an initial version of the Frame_order.test_simulate_rotor_z_axis system test. This is to check the frame_order.simulate user function rotor model along the z-axis. It currently fails due to a bug in the user function. Fixes for the Frame_order.test_simulate_rotor_z_axis system test. Now 6 atoms are being created at X, -X, Y, -Y, Z, and -Z, 100 Angstrom from the origin. This is required so that the CoM is at the origin, to allow the CoM-pivot vector to be unchanged at [1, 0, 0] so that the axis α angle of π/2 creates an axis parallel to Z. The origin to atom distance check has also been loosened due to the PDB truncation artifact. Fix for the Frame_order.test_pdb_model_free_rotor_xz_plane_tilt system test. This was broken while implementing the Frame_order.test_simulate_rotor_z_axis system test. Instead of shifting the 6 atom structure so its CoM is the pivot of the motion when creating the atoms, now the Frame_order.test_simulate_rotor_z_axis system test sets the average domain translation vector to the pivot to achieve the same result. This preserves the z-axis orientation of the rotor models. Created the Frame_order.test_simulate_free_rotor_z_axis system test. This is to check the frame_order.simulate user function for the free rotor model along the z-axis. Created the Frame_order.test_simulate_iso_cone_z_axis system test. This is to check the frame_order.simulate user function for the isotropic cone model along the z-axis. Created the Frame_order.test_simulate_iso_cone_free_rotor_z_axis system test. This is to check the frame_order.simulate user function for the free rotor isotropic cone model along the z-axis. Created the Frame_order.test_simulate_iso_cone_torsionless_z_axis system test. This is to check the frame_order.simulate user function for the torsionless isotropic cone model along the z-axis. Created the Frame_order.test_simulate_pseudo_ellipse_z_axis system test. This is to check the frame_order.simulate user function for the pseudo-ellipse model along the z-axis. Created the Frame_order.test_simulate_iso_cone_xz_plane_tilt system test. This is to check the frame_order.simulate user function for the torsionless isotropic cone model with a xz-plane tilt. Created the Frame_order.test_simulate_pseudo_ellipse_free_rotor_z_axis system test. This is to check the frame_order.simulate user function for the free rotor pseudo-ellipse model along the z-axis. Created the Frame_order.test_simulate_pseudo_ellipse_xy_plane_tilt system test. This is to check the frame_order.simulate user function for the pseudo-ellipse model with a xz-plane tilt. Created the Frame_order.test_simulate_pseudo_ellipse_torsionless_z_axis system test. This is to check the frame_order.simulate user function for the torsionless pseudo-ellipse model along the z-axis. Fix for the Frame_order.test_simulate_pseudo_ellipse_xz_plane_tilt system test name. This was mislabelled as Frame_order.test_simulate_pseudo_ellipse_xy_plane_tilt. Redesign of the pymol.frame_order user function. This user function was still fitting to the old design in the relax trunk. It has been updated for the frame_order_cleanup branch whereby the frame_order.pdb_model user function has been split up and the positional distribution has been replaced by the Brownian simulation user function frame_order.simulate. Better checking for the non-moving domain setup. The frame_order.pdb_model user function will now raise a RelaxError if the frame_order.ref_domain user function has not been called to set up the non-moving domain. Updated the frame_order.ref_domain user function for the current branch design. This user function was quite out of date. The alignment tensor checks have been removed, to allow this to be used in the absence of base data. And the user function description has been updated. Updated all frame order system tests for the frame_order.ref_domain user function requirement. Expanded all of the Frame_order.test_simulate_* system tests. Two atoms have been added to the origin [0, 0, 0], one in the moving domain, the other in the reference non-moving domain. The positions of these atoms are checked to make sure that the domain systems are correctly handled. Expanded the double rotor model description in the frame_order.select_model user function. Added the pipe_name argument to the frame order check_model() function. This is for the specific_analyses.frame_order.checks module. Converted the specific_analyses.frame_order.checks module to the new Check object design. This follows from http://wiki.nmr-relax.com/Relax_source_design#The_check_.2A.28.29_functions and the changes significantly simplify the checking objects. Improved checking for the frame order generate_pivot() function. The check_model() checking object is now called to make sure the frame order model has been specified, as this is essential for this function. Created two system tests for the frame_order.simulate user function for the double rotor model. These are Frame_order.test_simulate_double_rotor_mode1_z_axis and Frame_order.test_simulate_double_rotor_mode2_z_axis. Created two system tests for the frame_order.simulate user function for the double rotor model. These are Frame_order.test_simulate_double_rotor_mode1_xz_plane_tilt and Frame_order.test_simulate_double_rotor_mode2_xz_plane_tilt. Added relax scripts which match the Frame_order.test_test_simulate_* system tests. These are the tests of the frame_order.simulate user function. These were used to construct and visually check the Brownian simulation and PDB model representation in a molecular viewer. These could be a useful reference, so have been added to the repository. Fix for the frame order auto-analysis when only the 'rigid' model is optimised. The final summary table printout for the number of Sobol' points used was failing as there were no models in the table. The table is now only printed out if non rigid models are present in the model list. Introduced the nested_params_ave_dom_pos argument to the frame order auto-analysis. This allows the average domain position to be set to no rotations and translations rather than taking the average position from the rotor or free-rotor model. This can be useful when large motions are present causing the rigid model to have unreasonable domain positions. Fix for the frame_order.permute_axes user function description to allow the manual to be compiled. The table caption containing the user function name was causing the LaTeX compilation to fail. Therefore the captions have been rewritten to avoid the user function name. Modified the frame order system test check_chi2() method to test the statistics.model user function. This causes all of the Frame_order.test_cam_* system tests to fail, as the user function backend is not implemented for the frame order analysis. Implemented the frame order analysis backend for the statistics.model and statistics.aic user functions. This simply required aliasing the specific analysis API common _get_model_container_cdp() method to get_model_container(). Bug fix for the frame order specific analysis API base_data_loop() method. This was looping over non-existent PCS and RDC data. Now the alignment ID is checked for in the interatomic data container 'rdc' data structure and the spin container 'pcs' data structure, as well as values of None, before yielding the data. Created a large set of system tests for implementing the frame_order.distribute user function. This user function will be similar to frame_order.simulate. However instead of creating a PDB file with models from a pseudo-Brownian simulation, the frame_order.distribute user function will generate a PDB file of models forming a uniform distribution of structures covering the full frame order motional space. The new system tests are: Frame_order.test_distribute_double_rotor_mode1_xz_plane_tilt, Frame_order.test_distribute_double_rotor_mode1_z_axis, Frame_order.test_distribute_double_rotor_mode2_xz_plane_tilt, Frame_order.test_distribute_double_rotor_mode2_z_axis, Frame_order.test_distribute_free_rotor_z_axis, Frame_order.test_distribute_iso_cone_z_axis, Frame_order.test_distribute_iso_cone_xz_plane_tilt, Frame_order.test_distribute_iso_cone_torsionless_z_axis, Frame_order.test_distribute_pseudo_ellipse_xz_plane_tilt, Frame_order.test_distribute_pseudo_ellipse_z_axis, Frame_order.test_distribute_pseudo_ellipse_free_rotor_z_axis, Frame_order.test_distribute_pseudo_ellipse_torsionless_z_axis, Frame_order.test_distribute_rotor_z_axis. These are aliases for the equivalent Frame_order.test_simulate_* system tests which have had the 'type' keyword argument added, defaulting to 'sim', which allows to switch between the frame_order.simulate and frame_order.distribute user functions. The concept behind these system tests are the same for both user functions, so the code is shared. Created the front-end of the frame_order.distribute user function. This is a copy and modification of the frame_order.simulate user function, as the concepts are similar. Small modification of the frame_order.simulate user function. The GUI file opening dialog wildcard selectors are now set to all PDB file types (plain text, bzip2 compressed, and gzip compressed). Added the frame_order.distribute user function to the auto-analysis results output. This will allow both the pseudo-Brownian simulation and uniform distribution PDB files to be available to the user in all results directories (excluding the intermediate results for speed). Implemented the back-end of the frame_order.distribute user function. This follows the design of the pseudo-Brownian simulation frame_order.simulate user function. The specific_analyses.frame_order.uf.distribute() function has been created as a modified copy of the simulate() function of the same module. This simply performs checks and assembles the data, passing into the new lib.frame_order.simulate.uniform_distribution() function, which itself is a modified copy of the brownian() function in the same module. Introduced the max_rotations argument into the frame_order.distribute user function. This is used to prevent the user function from running forever. This happens whenever a cone opening angle or torsion angle is zero, and hence the random sampling of the rotational space will never find rotations within the motional distribution. Improved control of the frame_order.distribute user function in the frame order auto-analysis. The maximum number of rotations can now be set, and the argument for the total states for the distribution has been shortened. Speedup of the Frame_order.test_auto_analysis system test. After the introduction of the frame_order.distribute user function into the auto-analysis, the test was taking far too long to complete. Now the distribution arguments are set to low values to allow the test to pass in under a minute. Changed the default relax results compression type to bzip2 in the frame order auto-analysis. This was set to no compression for speeding up some system tests, however the system tests can set this for themselves. The Frame_order.test_auto_analysis system test now sets the results file compression type to bzip2. Changed the default max_rotations argument value to 100,000 in the frame_order.distribute user function. This decrease from one million is so the user function completes in a reasonable amount of time. The frame_order.distribute user function now warns when the maximum rotations are reached. Deleted a number of Frame_order.test_distribute* system tests. These are the four double rotor model tests. The frame_order.distribute user function cannot operate on these test cases as one of the two torsion angles are set to zero in the tests. Fix to allow Monte Carlo simulations to be repeated in the frame order analysis. The code for checking for pre-existing Monte Carlo simulation data structures and raising a RelaxError if anything is found has been deleted. Fix of a fatal bug preventing the frame order analysis to be run on a multi-processor system. The multi-processor code was calling the count_sobol_points() function of the specific_analyses.frame_order.optimisation module to give feedback when calling the minimise.execute or minimise.calculate user functions. However this was run in the slave command run() method, hence would be executed on the slave. The problem is that count_sobol_points() performs a number of checks on the current data pipe, however the slaves do not have any data pipes set up. Added the new 'atom_id' argument to the frame_order.distribute user function. This uses the new inverse selection functionality recently introduced into the trunk to delete all structural data not matching the atom_id from the copy of the loaded structural data string prior to generating the distribution of structures. Bug fix for the frame order target function (introduced recently). The copy.deepcopy() function is now used for all numpy input data to avoid the data from being modified between function calls. This is important for missing RDC and PCS data which is sent in as NaN values. In the target function __init__() method, the NaN values are replaced by 0.0 after the self.missing_rdc and self.missing_pcs structures have been by checking for NaN values. However the recent specific_analyses.frame_order.optimisation change in the Frame_order_minimise_command slave command to printout the number of integration points resulted in the target function being initialised twice, causing all NaN values to be 0.0 in the second initialisation. Hence all missing data was being treated as real data with values of 0.0. Created a new skeleton chapter in the relax manual for the frame order analysis. Added a theory section to the new frame order chapter. This is taken from an in-preparation supplement. Rearrangement of the frame order chapter in the manual. The theory section has been spun out into its own frame_order_theory.tex LaTeX file for better organisation. Added two more sections to the frame order chapter of the manual. This includes a frame order modelling section and PCS numerical integration section. Both are from a supplement from an in-preparation manuscript. Added a DOI and ISBN number to the bibliography. Moved the frame_order_theory.tex LaTeX file into the frame_order directory. Shifted the frame order model derivations into their own 'Advanced topics' chapter. Added the frame order sample scripts used in the CaM-IQ analysis. Added an introduction for the frame order chapter of the manual. Added a 'Data analysis' section to the frame order chapter of the manual. This includes the N-state and frame order analysis scripts required to perform a full analysis. Editing of the data analysis section of the frame order chapter of the manual. A PCS structural error figure has been added, all the text improved, and the scripts made to match those in sample_scripts/frame_order/. Added a section to the end of the frame order chapter about the long computation times. The 'scons clean' target now removes all LaTeX *.aux files. The docs/latex/frame_order/ directory is now also being checked for *.aux files. Removed many unnecessary references to relax. Removed lots of useless comments about book references. Added some images missing from the frame order chapter of the manual. Avoided a doubly defined label in the manual. Removed some duplicated text in the frame order models chapter of the manual. This is duplicated from the frame order analysis chapter. Indentation fix for allowing the API documentation to be properly compiled. Added a patch file for fixing Epydoc version 3.0.1. This is needed to allow the dot graph files names to be unique (by no longer truncating to 30 characters), and to allow epydoc to handle newer Graphvis versions. Improvements for the release checklist document. The backporting of the CHANGES file to trunk is now more obvious, and instructions for fixing Epydoc have been added. Clean up of some of the release instructions (for using vim). Added error catching to the find_unused_imports.py developer script. Fix for the error catching in the find_unused_imports.py developer script. The numerous pylint warnings are also sent to STDERR. Removed the printout of pylint STDERR messages in the find_unused_imports.py developer script. Elimination of a number of wildcard imports from some frame order timing scripts. This is to avoid excessive function imports. Removal of an unused import from the user_functions.frame_order module. Removal of unused imports from the test_suite/shared_data/frame_order/simulation scripts. Updated some unused frame order scripts to use the new minimise user function design. Unused import clean up in the test_suite/shared_data/curve_fitting/numeric_topology directory. All the scripts in this directory have been cleaned up to remove unused imports. In one case, commented out code was replaced with an 'if 0:' statement to silence the unused import warnings from the devel_scripts/find_unused_imports.py script. Unused import clean up in the test_suite/shared_data/curve_fitting/profiling directory. The scripts in this directory have been cleaned up to remove unused imports. Added an exception system to the find_unused_imports.py developer script. Sometimes pylint will give an "Unused import" warning for imports that are needed by the module. Therefore an exception list of the file name and module has been created to skip these warnings. The list covers the dep_check module and all of the profiling_*.py scripts in the directory test_suite/shared_data/dispersion/profiling/. Added a copyright notice to the find_unused_imports.py development script. This is mainly to indicate how out of date the script will be in the future. A directory can now be supplied on the command line for the find_unused_imports.py devel script. Changed the imports in the test_monte_carlo_mean.py script. This inconsequential change is to avoid false positives from the find_unused_imports.py devel script. Modifications of the test suite script for calculating synthetic CPMG data. The imports in cpmg_synthetic.py are now all used, rather than being commented out. This allows the find_unused_imports.py devel script to pass. Unused import cleanup of all scripts in the test_suite/shared_data/dispersion/ directories. This both removes unused imports, or uncomments but deactivates temporarily unused code. Removed unused imports from the scripts in the test_suite/shared_data/frame_order subdirectories. Removed unused imports from the spectrum system test base module. Removed unused imports from the relax_disp system test base module. Clean up of all unused imports in the system test scripts. Removed unused imports from the structure system test base module. Changed how the import of lib.regex in the test_regex unit tests is used. The module is no longer stored in the TestCase class namespace, but is rather called directly within the unit test. Changed the import of pipe_control.state in the test_state unit test module. Removed unused imports from the unit tests. Added another exception to the find_unused_imports.py devel script. This is for the test_suite.unit_tests._lib._geometry.test_rotations module which programatically obtains the imports using globals(). Added a workaround or hack for exceptions for circular imports in the find_unused_imports.py script. This is currently for the test_suite.unit_tests._lib.test___init__ and test_suite.unit_tests._lib._geometry.test___init__ modules. Removal of unused imports from the GUI test modules. Removed all unused imports from the pipe_control package. Added import exceptions for the lib.compat module in the find_unused_imports.py devel script. Added import exceptions for the lib.xml module in the find_unused_imports.py devel script. These are needed because of eval() function calls on XML stored Python data structures. Removed all unused imports from the relax library package. Removed all unused imports from the target_functions package. Removed unused imports from the developer scripts. Removed all unused imports from the specific_analyses package. Removed all unused imports from the auto_analyses package. Removed all unused imports from the numdifftools extern package. Removal of the last unused import from the target_functions package. Fix for the PCS system tests on old Python versions. The self.assertAlmostEqual() function cannot compare None values in earlier Python versions. MS Windows fix for the Frame_order.test_generate_rotor2_distribution system test. The locale.setlocale() function call for correctly setting up a spinning progress meter was failing on MS Windows. The error is now caught and the local setting skipped. Added Python 3.5 to the manual C module compilation script. Added Python 3.5 to the Python multiversion test suite script. Changes to the introduction of the frame order theory chapter of the manual. Version 3 of relax relax 3.3 series relax 3.3.9 Wrote a method to store parameter data and dispersion curves, for the protocol of repeated CPMG analysis. This is to prepare for analysis in other programs. The method loops through the data pipes, and writes the data out. It then writes a bash script that will concatenate the data in an matrix array style, for reading and processing in other programs. Task #7826: Write an Python class for the repeated analysis of dispersion data. Added to write out a collection script for χ2 and rate parameters. Task #7826: Write an Python class for the repeated analysis of dispersion data. In the collection bash script, removes spins which have not been fitted. Task #7826: Write an Python class for the repeated analysis of dispersion data. Fix for use of " instead of ' in bash script. Task #7826: Write an Python class for the repeated analysis of dispersion data. Adding option to minimise class function, to perform Monte Carlo error analysis. Task #7826: Write an Python class for the repeated analysis of dispersion data. Printout when minimising Monte Carlo simulations. Task #7826: Write an Python class for the repeated analysis of dispersion data. Added additional test to system test Relax_disp.test_bug_23186_cluster_error_calc_dw() to prove that Bug #23619 is invalid. Bug #23619: Stored chi2 sim values from Monte Carlo simulations does not equal normal chi2 values. Small fix for the shell script to collect data files, and not use the program "column" in the end. The line width becomes to large to handle for column. Task #7826: Write an Python class for the repeated analysis of dispersion data. Added a unit test that triggers the bug. Test added in test_delete_spin_all, and can be accessed with: relax -u _pipe_control.test_spin. Bug #23642: When deleting all spins for a residue, an empty placeholder is where select=True. Added sample data and analysis script, that will eventually show that there is not much difference in the sample statistics used for comparing the output of two very similar datasets. This is a multiple comparison test with many T-tests at once, where the familywise error is controlled by the Holm method. Even if the values are close to equal, and within the standard deviation, this procedure will reject up to 20% of the null hypothesis. This is not deemed as a suitable method. Bug #23644: monte_carlo.error_analysis() does not update the mean value/expectation value from simulations. Added Monte Carlo simulations to the N_state_model.test_absolute_T system test. This is to demonstrate a failure of the simulations in certain N-state model setups. Added a missing call to monte_carlo.initial_values in the N_state_model.test_absolute_T system test. This fixes the N_state_model.test_absolute_T system test, showing that there is not a problem with the Monte Carlo simulations. Added Monte Carlo and Bootstrap simulation support for the RDC and PCS Q factor calculations. The pipe_control.rdc.q_factors() and pipe_control.pcs.q_factors() functions have been modified to support Monte Carlo and Bootstrap simulations. The sim_index argument has been added to allow the Q factor for the given simulation number to be calculated. All of the Q factor data structures in the base data pipe now have *_sim equivalents for permanently storing the simulation values. For the simulation values, all the warnings have been silenced. Added simulation support for the RDC and PCS Q factors in the N-state model analysis. This is for both Monte Carlo and Bootstrap simulation. The simulation RDC and PCS values, as well as the simulation back calculated values are now stored via the minimise_bc_data() function of specific_analyses.n_state_model.optimisation in the respective spin or interatomic data containers. The analysis specific API methods now send the sim_index value into minimise_bc_data(), as well as the pipe_control.rdc.q_factors() and pipe_control.pcs.q_factors() functions. Silenced a warning in the N-state model optimisation if the verbosity is set to zero. This removes a repetitive warning from the Monte Carlo or Bootstrap simulations. Huge speed up for the Monte Carlo simulations in the N-state model analyses. This speed up is also for Bootstrap simulations and the frame order analysis. The change affects the monte_carlo.initial_values user function. The alignment tensor _update_object() method was very inefficient when updating the Monte Carlo simulation data structures. For each simulation, each of the alignment tensor data structures were being updated for all simulations. Now only the current simulations is being updated. This speeds up the user function by many orders of magnitude. Added functions for calculating the geometric mean and standard deviation to the relax library. These are the geometric_mean() and geometric_std() functions of the lib.statistics module. The implementation is designed to be fast, using numpy array arithmetic rather than Python loops. Created a simple unit test for the new lib.statistics.geometric_mean() function. Added a unit test for the new lib.statistics.geometric_std() function. Made a summarize function to compare results. Task #7826: Write an Python class for the repeated analysis of dispersion data. relax 3.3.8 Fix for the pipe_control.reset.reset() function when resetting the GUI in non-standard contexts. This is mainly for debugging scripts when simulating a GUI and hence the GUI reset() method does not exist. Created a GUI memory management debugging script for the align_tensor.init user function. This repetitively calls the reset, pipe.create and align_tensor.init user functions, and opening the GUI element for setting alignment tensor elements (the Sequence window). The pympler muppy_log file shows no memory leaks for these user functions on Linux systems. relax 3.3.7 Created the N_state_model.test_statistics system test. This system test will be used to implement the new statistics user function class consisting of the statistics.model and statistics.aic user functions for calculating and storing the [chi2, n, k] parameters and Akaike's Information Criterion statistic respectively. Added the structure.align user function to the renaming translation table. This is so relax identifies structure.align user functions in scripts to raise an error saying that the structure.superimpose user function should be used instead. Added the office-chart-pie set of Oxygen icons for use in the new statistics user function class. Created the empty statistics user function class. This adds the infrastructure for creating the statistics user functions. Small fix for the structure.add_model user function description. Created the frontend for the statistics.model user function. Created a wizard graphic for the statistics user functions. This is based on a number of Oxygen icons, as labelled in the SVG layer names. The statistics.model user function now uses the new statistics wizard graphic. Created the empty pipe_control.statistics module. This will be used for the backend of all of the statistics user functions. Fixes for the EPS versions of some Oxygen icons used in the relax manual. This is the actions.document-preview-archive and actions.office-chart-pie Oxygen icons used for the user function icons. The files were not created correctly in the Gimp. The export to EPS requires the width and height to be both set to 6 mm, and the X and Y offsets to zero. This allows the icon bounding boxes and sizes to match the other EPS icons. Implemented the backend of the statistics.model user function. The implementation heavily uses the specific analysis API, calling the calculate(), model_loop(), print_model_title(), model_statistics() and get_model_container() methods to do all of the work. The last of these API methods is yet to be implemented. Fix for the statistics.model user function backend. The API methods are now called with the model_info argument set to a keyword argument so that it is always passed in as the correct argument. Fix for the specific analysis API _print_model_title_global() common method. This method was horribly broken, as it was never used. The new statistics.model user function together with the N-state model uncovers this breakage. Defined the get_model_container() specific analysis API method. This base method raises a RelaxImplementError, therefore each analysis type must implement its own method (or use an API common method). Implemented the specific analysis API _get_model_container_cdp() commmon method. This is to be used for the get_model_container() for returning the current data pipe object as the model container. This is for the global models where the model information is stored in the pipe object rather than in spin containers. The N-state model now uses the _get_model_container_cdp() method. This is aliased as the get_model_container() specific analysis API method. Fix for the N_state_model.test_statistics system test - the probabilities were missing from k. Expanded the printouts from the statistics.model user function to include the statistics. Updated the N-state model num_data_points() function to use more modern integer incrementation. Fix for the N_state_model.test_statistics system test. The deselected spins and interatomic data containers are now taken into account for the RDC and PCS data point counts. Implementation of the statistics.aic user function. This is very similar to the statistics.model user function - the code was copied and only slightly modified. The new user function will calculate the current chi-squared value per model, obtain the model statistics, calculate the AIC value per model, and store the AIC value, chi-squared value and number of parameters in the appropriate location for the model in the relax data store. Created the empty lib.plotting.veusz module for graphing using Veusz. Shifted the lib.software.grace module to lib.plotting.grace. This follows from http://thread.gmane.org/gmane.science.nmr.relax.devel/7532 and http://thread.gmane.org/gmane.science.nmr.relax.devel/7536. Created XY-data functions for the plotting API of the relax library. These are currently copies of the heads of the lib.plotting.grace functions write_xy_data() and write_xy_header(). These lib.plotting.api functions (write_xy_data() and write_xy_header()) are set up to use the grace functions. Converted all of the Grace plotting in relax to use the plotting API of the relax library. Shifted the pipe_control.grace.write() function. This is now the format independent pipe_control.plotting.write_xy() function. The format argument has been added and this defaults to 'grace'. The grace.write user function has been updated to use the new backend. Updated the pcs.structural_noise user function to use the relax library plotting API. Fixes for the new pipe_control.plotting.write_xy() function. This includes missing imports which should have moved from pipe_control.grace, as well as shifting the axis_setup() function from the pipe_control.grace module into the pipe_control.plotting module. The rdc.corr_plot user function backend now uses the relax library plotting API. The write_xy_data() and write_xy_header() functions from lib.plotting.api are now uses instead of the equivalent pipe_control.grace functions which no longer exist. More import fixes for the new pipe_control.plotting.write_xy() function. Fix for the backend of the relax_disp.plot_disp_curves user function. The lib.plotting.api functions write_xy_data() and write_xy_header() require the format argument. Updated the relative stereochemistry auto-analysis to use the relax library plotting API. Huge speed up for the assembly of atomic coordinates from a large number of structures. The internal structural object validate_models() method was being called once for each structure when assembling the atomic coordinates. This resulted in the _translate() internal structural object method, which converts all input data to formatted strings, being called hundreds of millions of times. The problem was in lib.structure.internal.coordinates.assemble_atomic_coordinates(), in that the one_letter_codes() method, which calls validate_models(), was called for each molecule encountered. The solution was not to validate models in one_letter_codes(). Huge speed up of the internal structural object validate_models() method. The string formatting to create pseudo-PDB records and the large number of calls to the _translate() method for atomic information string formatting has been shifted to only be called when atomic information does not match. Instead the structural information is directly compared within a large if-else statement. Created the Structure.test_atomic_fluctuations_no_match system test. This demonstrates a failure in the operation of the structure.atomic_fluctuations user function when the supplied atom ID matches no atoms. Fix for the Structure.test_atomic_fluctuations_no_match system test. The structure.atomic_fluctuations user function will now raise a RelaxError when no data corresponding to the atom ID can be found, so the test now checks for this. Created the unit test infrastructure for the lib.structure.internal.object module. Created the Test_object.test_add_atom_sort unit test. This is from the _lib._structure._internal.test_object unit test module. The test will be used to implement the sorting of input data by residue number in the add_atom() internal structural object method. This will mean that added atoms will be placed in residue sequence order, so that output PDB files are correctly ordered. Implementation of methods for sorting sequence data in the internal structural object. The information is sorted in the molecule container level using the new MolContainer._sort() private method. This uses the _sort_key() helper method which determines what the new order should be. This is used as the 'key' argument for the Python sort() method. Instead of list shuffling, new lists in the correct order are created. Although not memory efficient, this might be faster than shuffling. The loading of structural data now sorts the data if the merge flag is True. The pack_structs() method for sorting the data will now call the new MolContainer._sort() function is the data is being merged. This is to ensure that the final structural data is correctly ordered. Fixes for a number of Structure system tests for the sorted structural data changes. Modified the structure.read_pdb user function backend to skip water molecules. All residues with the name 'HOH' are now skipped when loading PDB files. This is implemented in the MolContainer.fill_object_from_pdb() method, and a RelaxWarning is printed listing the residue numbers of all skipped waters. Modified the Structure.test_read_pdb_1UBQ system test for the new water skipping feature. As the structure.read_pdb user function will now skip waters, the last atom in the structural object will now be the last ubiquitin atom and not the last water atom. Modified the Test_object.test_add_atom_sort unit test to check atom connectivities. This is from the _lib._structure._internal.test_object unit test module. The problem is that the MolContainer._sort() method for sorting the structural data currently does not correctly update the bonded data structure. Completed the implementation of the sorting of structural data in the internal structural object. The MolContainer._sort() private method now changes the connect atom indices in the bonded data structure to the new sorted indices. Created new system tests for implementing new functionality for the structure.mean user function. This includes the Structure.test_mean_models and Structure.test_mean_molecules. The idea is to convert the user function to the new pipes/models/molecules/atom_id design. This will allow molecules with non-identical sequences and atomic compositions to be averaged. The set_mol_name and set_model_num arguments from the structure.read_pdb, structure.read_gaussian, and structure.read_xyz user functions will also be implemented to allow the mean structure to be stored alongside the other molecules. Some fixes for the checks in the Structure.test_mean_molecules system test. Fix for the structure.mean user function call in the Structure.test_mean_models system test. Expanded the checking in all the Structure.test_mean* system tests to cover all atomic information. This includes the Structure.test_mean, Structure.test_mean_models, and Structure.test_mean_molecules system tests. All structural data is now carefully checked to make sure that the structure.mean user function operates correctly. Converted the structure.mean user function to the new pipe/model/molecule/atom_id design. This allows the average structure calculation to work on atomic coordinates from different data pipes, different structural models, and different molecules. The user function backend uses the new pipe_control.structure.main.assemble_structural_coordinates() function to assemble the common atom coordinates, molecule names, residue names, residue numbers, atom names and elements. All this information is then used to construct a new molecule container for storing the average structure in the internal structural object. To allow for the averaged structural data to be stored, the internal structural object method add_coordinates() has been created. This is modelled on the PDB, Gaussian, and XYZ format loading methods. The internal structural object mean() method is no longer used, but remains for anyone who might have interest in the future (though as it is untested, bit-rot will be a problem). Small correction for the structure.read_pdb user function description. Created the Structure.test_read_merge_simultaneous system test. This is to demonstrate a failure in the structure.read_pdb user function when merging multiple molecules from one file into one molecule simultaneously with a single user function call. Added some error checking for the monte_carlo.setup user function. A RelaxError is now raised if the number of simulations is less than 3. This prevents Python errors when later calling the monte_carlo.error_analysis user function. Test suite fixes for the error checking in the monte_carlo.setup user function. The number of simulations has been increased from either 1 or 2 in all tests to the minimal number of simulations (3). Created the Structure.test_bug_23293_missing_hetatm system test. This is to catch bug #23293, the PDB HETATM loading error whereby the last HETATM record is sometimes not read from the PDB file. Small fix for the chain IDs in the Structure.test_bug_23293_missing_hetatm system test. Created the Structure.test_multi_model_and_multi_molecule system test. This is used to check the loading and writing of a multi-model and multi-molecule PDB file. The test shows that this functions correctly. Modified the Structure.test_multi_model_and_multi_molecule test to check for model consistency. This is just for better test suite coverage of the handling of PDB structural data. Created the Structure.test_bug_23294_multi_mol_automerge system test. This is used to catch bug #2329, the automatic merging of PDB molecules resulting in an IndexError. It reads in the 'in.pdb' PDB file attached to the bug report, now named 'bug_23294_multi_mol_automerge.pdb', to show the IndexError. The test also checks the structure.write_pdb user function to make sure that the output PDB file contains a single merged molecule. Added the PDB file to the repository for the Structure.test_bug_23294_multi_mol_automerge system test. Fix for the Structure.test_bug_23294_multi_mol_automerge system test. The MASTER PDB record has been added to the data to check for, as this will be produced by the structure.write_pdb user function. Improved the RelaxWarning for missing atom numbers in the PDB CONECT records. This is for the structure.read_pdb user function. Now only one warning is given for the entire PDB file listing all of the missing atom numbers rather than one warning per missing atom. This can significantly compact the warnings, removing a lot of repetition. Improved the quality of the printouts from the structure.read_pdb user function. This also affects the structure.read_gaussian and structure.read_xyz user functions. The messages about adding new molecules or merging with existing molecules has been significantly improved. The text with the model information is now only printed if the model number is present in the PDB file or has been supplied by the user. Fixes for all of the PDB documentation HTML links in the docstrings. The PDB have shifted their documentation from http://www.wwpdb.org/documentation/format33/v3.3.html to http://www.wwpdb.org/documentation/file-format/format33/v3.3.html, stupidly without redirects. This will create dead links in the relax API documentation at http://www.nmr-relax.com/api/3.3/, as well as the older API documentation (http://www.nmr-relax.com/api/2.2/, http://www.nmr-relax.com/api/3.0/, http://www.nmr-relax.com/api/3.1/, http://www.nmr-relax.com/api/3.2/). Created the Structure.test_bug_23295_ss_metadata_merge system test. This is to catch bug #23295, the PDB secondary structure HELIX and SHEET records not updated when merging molecules. This uses the '2BE6_secondary_structure.pdb' structure file and 'test.py' relax script contents as the test, checking the HELIX and SHEET records. Added one more check to the Structure.test_bug_23295_ss_metadata_merge system test. The test would pass if no HELIX or SHEET records were to be written to the PDB file. Fix for the Structure.test_bug_23295_ss_metadata_merge system test and additional printouts. Fix for the Structure.test_pdb_combined_secondary_structure system test. The SHEET PDB record check was incorrect and was checking for the improperly formatted atom name field, which has now been fixed in relax. Large speed up of the structure.web_of_motion user function. With the introduction of the _sort() internal structural object method and it being called by the add_atom(), the structure.web_of_motion user function was now painfully slow. As sorting the structural data is unnecessary for the backend of this user function, the add_atom() boolean argument 'sort' has been added to turn the sorting on and off, and the structure.web_of_motion backend now sets this to False. Fix for the internal structural object unit test Test_object.test_add_atom_sort. This test of the _lib._structure._internal.test_object unit test module now requires the sort argument set to True when calling the add_atom() method. Improvement for a RelaxError message when assembling structural data but no coordinates can be found. Created a series of unit tests for implementing a new internal structural object feature. These tests check a new 'inv' argument for the selection() structural object method for allowing all atoms not matching the atom ID string to be selected. Implemented the new 'inv' argument for the selection() structural object method. This allows for all atoms not matching the atom ID string to be selected. The unit tests for this argument now all pass, validating the implementation. Improvement for the structure.mean user function. This can now be used to store an averaged structure in an empty data pipe. Previously structural data needed to be present in the current data pipe for the user function to work. Created a system test to show a limitation of the rdc.copy user function. Currently, it cannot work when spin systems in two data pipes are different. The system test will be used to implement the support. Simplification of the new Rdc.test_rdc_copy_different_spins system test. This no longer tests the deletion of interatomic data containers by the spin.delete user function, something which is not implemented. Some more fixes for the Rdc.test_rdc_copy_different_spins system test. The residue.delete and not spin.delete user function is required to delete the sequence data. Another small fix for the new Rdc.test_rdc_copy_different_spins system test. The rdc.copy user function requires the pipe_to argument to be supplied in this case. Expansion of the Rdc.test_rdc_copy_different_spins system test. The interatomic data containers are now defined via the interatom.define user function, which requires the spin.element user function to set up the element information. A printout has also been added to demonstrate a failure in the pipe_control.interatomic.interatomic_loop() function in handling the correct data pipe. Some more modifications for the Rdc.test_rdc_copy_different_spins system test. One of the interatomic data containers does not have RDC data, as it is not present in the original data pipe, hence this is checked for. And the printouts have more formatting. Expanded the functionality of the rdc.copy user function. The user function will now operate on two data pipes with different spin sequences. If the interatomic data container is missing from the target data pipe, a warning is given. And if the interatomic data container is not present in the source data pipe, nothing will be copied. Modified the rdc.copy user function to printout all copied RDC values and errors. Created the Rdc.test_rdc_copy_back_calc system test. This will be used to implement the back_calc Boolean argument for the rdc.copy user function to allow not only measured, but also back-calculated RDC values to be copied. Modified the rdc.copy printout of RDCs to occur for each alignment ID. Implemented the back_calc argument for the rdc.copy user function. This allows the back-calculated RDCs to be additionally copied together with the real value and error. Small formatting change for the rdc.copy user function printouts. Created the Pcs.test_pcs_copy_different_spins system test. This will be used to show a limitation of the pcs.copy user function in that it cannot copy data between two data pipes with different molecule, residue, and spin sequences. Added a printout of the alignment ID for the pcs.copy user function. This is to match the rdc.copy user function. Created the Pcs.test_pcs_copy_back_calc system test. This will be used to implement the back_calc Boolean argument for the pcs.copy user function to allow not only measured, but also back-calculated PCS values to be copied. It matches the equivalent Rdc.test_rdc_copy_back_calc system test. Implemented the back_calc argument for the pcs.copy user function. This allows the back-calculated PCSs to be additionally copied together with the real value and error. The implementation simply copies that of the rdc.copy user function. Added full per-alignment data printouts to the pcs.copy user function to match rdc.copy. The feedback is important to know what was actually copied. Modified the pcs.copy user function to handle different spin sequence between data pipes. Fixes for the Pcs.test_pcs_copy_different_spins and Pcs.test_pcs_copy_back_calc system tests. Fix for the pcs.copy user function for a recently introduced problem. The data pipe for the spin_loop() function must be supplied. The pcs.copy user function now skips deselected spins. Modified the N_state_model.test_data_copying system test to skip deselected spins. Added more checks to the three Pcs.test_pcs_copy* system tests. Added more checks to the three Rdc.test_rdc_copy* system tests. Created the Rdc.test_calc_q_factors_no_tensor system test. This is to demonstrate a failure in the rdc.calc_q_factors user function when no alignment tensor is present. In addition, the test is also triggering an earlier problem of spin isotope information being missing. However the isotope is not required if the tensor is absent. The Rdc.test_rdc_copy_* system tests now check for the 'rdc_data_types' data structure. This is in the Rdc.test_rdc_copy_different_spins and Rdc.test_rdc_copy_back_calc system tests and shows that the rdc.copy user function fails to duplicate this information. The Rdc.test_rdc_copy_* system tests now check for the 'absolute_rdc' data structure. This is in the Rdc.test_rdc_copy_different_spins and Rdc.test_rdc_copy_back_calc system tests and shows that the rdc.copy user function fails to duplicate this information as well. Expanded the rdc.copy user function to copy the RDC data type and absolute RDC flag information. Created the Rdc.test_corr_plot system test to check the rdc.corr_plot user function. This shows that this poorly tested function works correctly. Created the Pcs.test_corr_plot system test to check the pcs.corr_plot user function. This user function is poorly tested, and this test triggers a series of bugs. Added the 'title' and 'subtitle' arguments to the pcs.corr_plot user function. This problem was detected by the new Pcs.test_corr_plot system test. The pcs.corr_plot user function now matches the rdc.corr_plot user function in terms of arguments. Completed the Pcs.test_corr_plot system test. The file contents are now known and have been carefully checking in Grace. Clarification of the RDC and PCS Q factors. This affects the rdc.calc_q_factors and pcs.calc_q_factors user functions, as well as all other operations involving the calculation of Q factors. The printouts have been modified to clarify if the normalisation is via the tensor size (2Da2(4 + 3R)/5) or via the sum of data squared, and the separation of the two is now clearer. This allows for better RDC vs. PCS comparisons. In addition, the data pipe variable names have been updated to reflect the normalisation, so it is instantly known when looking at the XML contents of results or save files which was used. The backwards compatibility hooks have been modified to support the data pipe variable name changes. The align_tensor.copy user function 'tensor_from' argument can now be None. This is to enable the copying of all alignment tensors from one data pipe to another. Created the Align_tensor.test_copy_pipes system test. This is to show a problem in the align_tensor.copy user function when copying all tensors between data pipes. Modified the pipe_control.align_tensor.align_data_exists() function to handle no tensor IDs. If no tensor ID is supplied, this will then return True if any alignment data exists. Improvement for the align_tensor.copy user function. The user function has been modified to allow all alignment tensors to be copied between two data pipes. This allows the Align_tensor.test_copy_pipes system test to pass. Fixes for the align_tensor.copy user function argument unit tests. The tensor_from and tensor_to arguments can now be None. Created the Align_tensor.test_copy_pipes_sims system test. This demonstrates a failure of the align_tensor.copy user function when Monte Carlo simulated tensors are present. Deleted the data_store.align_tensor.AlignTensorSimList.append() method. This replacement list method was proving fatal when copy.deepcopy() is called on the alignment tensor object. The change allows the Align_tensor.test_copy_pipes_sims system test to pass. Huge speed up for loading results and state files with Monte Carlo simulation alignment tensors. The reading of the alignment tensor component of XML formatted results and state files has been modified. Previously the data_store.align_tensor.AlignTensorData._update_object() method for updating the alignment tensor object (for values, errors, simulations) was being called once for each Monte Carlo simulation. Now is it called only once for all simulations. In one test, the reading of the save file with 500 simulations dropped from 253.7 to 10.0 seconds. Added an extra check for the assembly of RDC data. This is in the pipe_control.rdc.return_rdc_data() function and the check is for any unit vectors set to None, which is a fatal condition. Improved the RelaxError message from the RDC assembly function when unit vectors are None. Added a new warning to the interatom.unit_vectors user function if data is missing. This is to aid in detecting problems earlier before unit vectors of None are encountered by other parts of relax. Modified the rdc.corr_plot user function to skip deselected interatomic data containers. This would normally happen as no back-calculated data is normally present. However, if data has been copied from elsewhere, this may not always be the case. Created the Sequence.test_bug_23372_read_csv system test. This is to catch bug #23372, the sequence.read failure with CSV files. It uses a truncated version of the CSV data file attached to sr #3219. Converted the lib.sequence.validate_sequence() to the checking function design. This is the checking function design documented at Relax_source_design#The_check_.2A.28.29_functions. The validate_sequence() function has been renamed to check_sequence_func() and the checking object is called check_sequence. It removes the string processing hack to convert RelaxErrors to RelaxWarnings in the lib.sequence.read_spin_data() function, avoiding strange messages such at "RelaxWarning: ror: The sequence data in the line..." as seen in the Sequence.test_bug_23372_read_csv system test. Small typo fix for the Sequence.test_bug_23372_read_csv system test. Added the raise_flag argument to the lib.sequence.read_spin_data() function. This is to allow the missing data RelaxError to be deactivated. Modified the spectrum.read_intensities user function backend to be more robust. This affects the generic formatted peak lists, via the lib.spectrum.peak_list.intensity_generic() function. The peak list reading will now continue reading the file after corrupted lines have been encountered. Python 3 improvement for the rdc.corr_plot and pcs.corr_plot user functions. The world view is now set in floating point numbers. In Python 2, the math.ceil() and math.floor() functions return floats, whereas in Python 3 these functions return integers. The behaviour is now consistent in both Python versions, fixing a few system tests. Modified the internal formatting of the data section of the Grace 2D graph files. This affects the lib.plotting.grace.write_xy_data() function. The formatting is now more consistent, with the X value now set to a fixed number of decimal places, and hence will no longer change between Python 2 and 3. The data is now all right justified as well, for easier reading. All affected system tests have been updated for the new format. Epydoc documentation fix for the lib.structure.pdb_write._handle_atom_name() function. relax 3.3.6 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. relax 3.3.5 Added a sentence to the start of the citation chapter about http://www.nmr-relax.com links. This is to convince people to more freely use this URL. In that way, the relax search engine ranking should be significantly increased. And it will be easier for new users to get into relax. Removing the automatic function for error analysis per field in the relaxation dispersion auto-analysis. This function is moved into pipe_control/spectrum.py. Added the function pipe_control.spectrum.error_analysis_per_field(), as an automatic way of submitting subset IDs per field for error analysis. For the pipe_control.spectrum.error_analysis_per_field(), added additional printout of subset IDs used for error analysis. In the auto_analysis.relax_disp module, used the new spectrum.error_analysis_per_field user function to calculate the peak intensity errors. Reinserted the error_analysis() function in the auto class of relaxation dispersion. This function only checks if the error analysis has not been be performed before, and then decides to call the spectrum.error_analysis_per_field user function. The implementation can be tested with the Relax_disp.test_estimate_r2eff_err_auto system test. In pipe_control.spectrum.error_analysis_per_field() removed the checks which would stop the calculation of the errors. This function will now always run, which will make it possible for the user to try different error calculations. Copy of the system test script peak_lists.py to spectrum.py. This is for the implementation of calculation of signal to noise ratio, selection and deselection. Initialised first test in the Spectrum system test class. This is simply loading some intensity data, and checks data. The system test Spectrum.test_signal_noise_ratio will be expanded to test the calculation of the signal to noise ratio. Added the Spectrum system test class to the init file, so these system tests can be executed. Added the pipe_control.spectrum.signal_noise_ratio() backend function, for calculation of the signal to noise ratio per spin. Added system test Spectrum.test_grace_int, to test plotting the intensity per residue. This is to prepare for a grace plotting of the signal to noise level per residue. Also added additional tests for signal to noise ratio calculation in the system test Spectrum.test_signal_noise_ratio. Added system test Spectrum.test_grace_sn_ratio to help implement plotting the signal to noise ratio per residue. Added the common API Parameter structure 'sn_ratio' in parameter_object. For the specific analysis of "noe", "relax_disp", and "relax_fit", initialised the sn_ratio parameter structure. Added float around values in signal_noise_ratio() function. Made the spectrum.sn_ratio user function smaller. Added two new system tests Spectrum.test_deselect_sn_ratio_all and Spectrum.test_deselect_sn_ratio_any. These test the deselect.sn_ratio user function, to deselect spins with a signal to noise ratio lower than the specified ratio. Added function in pipe_control.spectrum.sn_ratio_deselection(), a function to deselect spins according to the signal to noise ratio. The function is flexible, since it possible to use different comparison operators. And the function can be switched, so a selection is made instead. Added the new deselect.sn_ratio user function to deselect spins according to their signal to noise ratio. Added new backend function in pipe_control.spectrum.sn_ratio_selection. This is to select spins with a signal to noise ratio, higher or lower than the specified ratio. Added two new system tests Spectrum.test_select_sn_ratio_all and Spectrum.test_select_sn_ratio_any. These test the select.sn_ratio user function. Added the new select.sn_ratio user function to select spins with signal to noise ratio above a specified ratio. The default ratio for signal to noise selection is 10.0. But should probably be 50-100 instead. The default of 'all_sn' is True, meaning that all signal to noise ratios for the spins needs to pass the test. Small fix for standard values in deselect.sn_ratio user function. The standard values will deselect spins which have at least one signal to noise ratio which is lower than 10.0. Small fix for the backend of spectrum sn_ratio_selection() and sn_ratio_deselection(). The standard values have been changed. Fix for the window size in dx.map user function. The size of the windows was not compatible with the latest change. Documentation fix in the manual for the lower and upper bonds for parameters in the grid search. Documentation fix in the manual for the lower and upper bonds for parameters in the minimisation. Documentation fix in the manual for the scaling values of parameters in the minimisation. The scaling helps the minimisers to make the same step size for all parameters when moving in the χ2 space. Added a devel script which can quickly convert oxygen icons to the desired sizes. Extended the devel script image size converter. Adding new oxygen icon in all needed sizes. Comment fix in user function select.sn_ratio and deselect.sn_ratio. Important fix for the spectrum.error_analysis_per_field user function. This is for the compilation of the user manual. The possessive apostrophe should not be used in the text "spectrum ID's". This grammar error triggers an unfortunate bug in the docstring fetching script docs/latex/fetch_docstrings.py whereby the script thinks that ' is the start of a quote. Added a compressed EPS version of the 128x128/actions/document-preview-archive Oxygen icon. The EPS bounding box was manually changed to 0 0 18 18 in a text editor. The scanline translation parameters were also fixed by changing them all to 18 as well. This allows the icon to be used in the relax manual. Fix for the blacklist objects in data_store.data_classes.Element.to_xml(). The class blacklist variable was not being taken into account. Added the norm_type argument to the grace.write user function. This is in response to http://thread.gmane.org/gmane.science.nmr.relax.devel/7392/focus=7438. This norm_type argument can either be 'first' or 'last' to allow different points of the plot to be the normalisation factor. The default of 'first' preserves the old behaviour of first point normalisation. The relax_fit_saturation_recovery.py system test script now sets the norm_type argument. This is for testing out this new option for the grace.write user function. The new grace.write user function norm_type argument has been activated. The argument is now passed from pipe_control.grace.write into the write_xy_data() function of the lib.software.grace module, and is used to select which point to use for the normalisation. The relaxation exponential curve-fitting auto-analysis now sets the normalisation type. This is for the new grace.write user function. If the model for all spins is set to 'sat', then the norm_type will be set to 'last'. This allows for reasonable normalised curves for the saturation recovery R1 experiment types. Change for norm_type variable in the relaxation exponential curve-fitting auto-analysis. This is now set to 'last', not only for the saturation recovery, but now also for the inversion recovery experiment types. This ensures that the normalisation point is the steady state magnetisation peak intensity. Cleared the list of blacklisted objects for the cdp.exp_info data structure. The data_store.exp_info.ExpInfo class blacklist variable had previously not been used. But after recent changes, the list was now active. As all the contents of the container were blacklisted, the container was being initialised as being empty when reading the XML formatted state or results files. Therefore the blacklist is now set to an empty list. Improvements for all of the tables of the relaxation dispersion chapter of the manual. The captions are now the full width (or height for rotated tables) of the page in the PDF version of the manual. The \latex{} command from the latex2html package has been used to improve the HTML versions of the tables by deactivating the landscape environment, the cmidrule command, and the caption width commands. This results in properly HTML formatted tables, rather than creating a PNG image for the whole table. These should significantly improve the tables in the webpages http://www.nmr-relax.com/manual/Comparison_of_dispersion_analysis_software.html, http://www.nmr-relax.com/manual/The_relaxation_dispersion_auto_analysis.html, and http://www.nmr-relax.com/manual/Dispersion_model_summary.html. Created the Structure.test_align_molecules system test. This will be used to extend the functionality of the structure.align user function to be able to align different molecules in the same data pipe, rather than requiring either models or identically named structures in different data pipes. Modified the Structure.test_align_molecules system test. This now simultaneously checks both the pipes and molecules arguments to the structure.align user function. More changes for the new Structure.test_align_molecules system test. Some more fixes for the Structure.test_align_molecules system test. Change to the Structure.test_align system test. The molecules argument for the structure.align user function has been changed to match the models argument, in that it now needs to be a list of lists with the first dimension matching the pipes argument. This change is to help with the implementation of the new structure.align functionality. Implemented the new molecules argument for the structure.align user function. In addition to accepting the new argument, the user function backend has been redesigned for flexibility. The assembly of coordinates and final rotations and translations now consist of three loops over desired data pipes, all models, and all molecules. If the models or molecules arguments are supplied, then the models or molecules in the loop which do not match are skipped. This logic simplifies and cleans up the backend. Created the Structure.test_rmsd_molecules system test. This will be used to implement a new molecules argument for the structure.rmsd user function so that the RMSD between different molecules rather than different models can be calculated. Implemented the new molecules argument for the structure.rmsd user function. This allows the RMSD between different molecules rather than different models to be calculated, extending the functionality of this user function. Created the Structure.test_displacement_molecules system test. This will be used to implement the new molecules argument for the structure.displacement user function. Implemented the molecules argument for the structure.displacement user function. This allows the displacements (translations and rotations) to be calculated between different molecules rather than different models. This information is stored in the dictionaries of the cdp.structure.displacement object with the keys set to the molecule list indices. Created the Structure.test_find_pivot system test. This is to check the structure.find_pivot user function as this algorithm is currently not being checked in the test suite. Created the Structure.test_find_pivot_molecules system test. This will be used to implement support for a molecules argument in the structure.find_pivot user function so that different molecules rather than different models can be used in the analysis. Increased the precision of pivot optimisation in the Structure.test_find_pivot_molecules system test. Implemented the molecules argument for the structure.find_pivot user function. This allows the motional pivot optimisation between different molecules rather than different models. Shifted the atomic assembly code from the structure.align user function into its own function. The new function assemble_coordinates() of the pipe_control.structure.main module will be used to standardise the process of assembling atomic coordinates for all of the structure user functions. This will improve the support for comparing different molecules rather than different models as missing atoms or divergent primary sequence are properly handled, and it has multi-pipe support. Changed the argument order for the structure.align user function. The standardised order will now be pipes, models, molecules, atom_id, etc. Converted the structure.find_pivot user function to the new pipes/models/molecules/atom_id design. This allows the motional pivot algorithm to work on atomic coordinates from different data pipes, different structural models, and different molecules. The change allows the Structure.test_find_pivot_molecules system test to now pass, as missing atomic data is now correctly handled. The user function backend uses the new pipe_control.structure.main.assemble_coordinates() function. The Structure.test_find_pivot and Structure.test_find_pivot_molecules system tests have been updated for the user function argument changes. Shift of the atomic coordinate assembly code into the relax library. Most of the pipe_control.structure.main.assemble_coordinates() function has been shifted into the assemble_coord_array() function of the new lib.structure.internal.coordinates module. The pipe_control function now only checks the arguments and assembles the structural objects from the relax data store, and then calls assemble_coord_array() to do all of the work. This code abstraction increases the usefulness of the atomic coordinate assembly and allows it to be significantly expanded in the future, for example by being able to take sequence alignments into consideration. Tooltip standardisation for the structure.align and structure.find_pivot user functions. The coordinate assembly function now returns list of unique IDs. This is for each structural object, model and molecule. Changed the structure ID strings returned by the assemble_coord_array() function. This is from the lib.structure.internal.coordinates module. The structural object name is only included if more than one structural object has been supplied. More improvements for the structure ID strings returned by the assemble_coord_array() function. Converted the internal structural displacement object to use unique IDs rather than model numbers. This allows the object to be much more flexible in what types of structures it can handle. This is in preparation for a change in the structure.displacement user function. Converted the structure.displacement user function to the new pipes/models/molecules/atom_id design. This allows the displacements to be calculated between atomic coordinates from different data pipes, different structural models, and different molecules. The user function backend has been hugely simplified as it now uses the new pipe_control.structure.main.assemble_coordinates() function. The Structure.test_displacement system test has been updated for the user function argument changes. Another refinement for the structure ID strings returned by the assemble_coord_array() function. Updated the Structure.test_displacement_molecules system test. This is for the changes to the structure.displacement user function. Docstring spelling fixes for the steady-state NOE and relaxation curve-fitting auto-analyses. Converted the structure.rmsd user function to the new pipes/models/molecules/atom_id design. This allows the RMSD calculation to work on atomic coordinates from different data pipes, different structural models, and different molecules. The user function backend uses the new pipe_control.structure.main.assemble_coordinates() function. The Structure.test_rmsd_molecules system test has been updated for the user function argument changes. Created the internal structural object model_list() method. This is to simplify the assembly of a list of all current models in the structural object. Converted the structure.superimpose user function to the new pipes/models/molecules/atom_id design. The user function arguments have not changed, however the backend now uses the new pipe_control.structure.main.assemble_coordinates() function. This is to simply decrease the number of failure points possible in the structure user functions. The change has no effect on the user function use or results. Documentation fix for the assemble_coord_array() function. The return values for lib.structure.internal.coordinates.assemble_coord_array() were incorrectly documented. Modified the Structure.test_bug_22070_structure_superimpose_after_deletion system test. This now calls the structure.align user function after calling the structure.superimpose user function to better test a condition that can trigger bugs. Fixes for the structure.superimpose and structure.align user functions. The fit_to_mean() and fit_to_first() functions of lib.structure.superimpose where being incorrectly called, in that they expect a list of elements and not lists of lists. Code refactorisation for the structure.align user function backend. The looping over data pipes, model numbers, and molecule names, skipping those that don't match the function arguments, has been shifted into the new structure_loop() generator function of the pipe_control.structure.main module. This function assembles the data from the data store and then calls the new loop_coord_structures() generator function of the lib.structure.internal.coordinates module which does all of the work. Some docstring expansions for the pipe_control.structure.main module functions. Refactored the descriptions of a number of structure user functions. This includes the structure.align, structure.displacement, structure.find_pivot, structure.rmsd and structure.superimpose user functions. The paragraph_multi_struct and paragraph_atom_id module strings have been created and are shared as two paragraphs for each of these user function descriptions. This standardises the pipe/model/molecule/atom_id descriptions. The user function wizard page sizes have been updated for these changes. Changed the design of the lib.structure.internal.coordinates.assemble_coord_array() function. The elements_flag argument has been renamed to seq_info_flag. If this is set, then in addition to the atomic elements, the molecule name, residue name, residue number, and atom name is now assembled and returned. This information is now the common information between the structures, hence the return values for the elements are a list of str rather than list of lists. All of the code in pipe_control.structure.main has been updated for the change. Fix for the structure.align user function if no data pipes are supplied. The pipes list was no longer being created as it was shifted to the assemble_coordinates() function, however it is required for the translation and rotation function calls. Converted the structure.web_of_motion user function to the new pipe/model/molecule/atom_id design. This allows the web of motion representation to work on atomic coordinates from different data pipes, different structural models, and different molecules. The user function backend uses the new pipe_control.structure.main.assemble_coordinates() function to assemble the common atom coordinates, molecule names, residue names, residue numbers, atom names and elements. All this information is then used to construct the new web of motion PDB file. Therefore the entire backend has been rewritten. The Structure.test_web_of_motion_12, Structure.test_web_of_motion_13, and Structure.test_web_of_motion_all system tests have all been updated for the changed structure.web_of_motion user function arguments. In addition, the system tests Structure.test_web_of_motion_12_molecules, Structure.test_web_of_motion_13_molecules and Structure.test_web_of_motion_all_molecules have been created as a copy of the other tests but with the 3 structures loaded as different molecules. Fix for the IDs returned by lib.structure.internal.coordinates.assemble_coord_array(). The list of unique structure IDs was being incorrectly constructed if multiple molecules are present but the molecules argument was not supplied. It would be of a different size to the coordinate data structure. Fix for the Structure.test_displacement system test for the assemble_coord_array() function bugfix. Modified the Structure.test_align system test to show a failure of the structure.align user function. The alignment causes all atoms in the structural object to be translated and rotated, whereas it should only operate on the atoms of the atom_id argument. Modified the Structure.test_superimpose_fit_to_mean system test. This is also to demonstrate a bug, this time in the structure.superimpose user function, in which the algorithm causes a translation and rotation of all atoms rather than just those selected by the atom_id argument. Modified some system tests of the structure.align and structure.superimpose user functions. The displace_id argument has been introduced for both of these user functions for finer control over which atoms are translated and rotated by the algorithm. This allows, for example, to align structures based on a set of backbone heavy atoms while the protons and side chains are displaced by default. Or if a domain is aligned, then just that domain can be displaced. Added the displace_id argument to the structure.align and structure.superimpose user functions. This gives both of these user functions finer control over which atoms are translated and rotated by the algorithm. This allows, for example, to align structures based on a set of backbone heavy atoms while the protons and side chains are displaced by default. Or if a domain is aligned, then just that domain can be displaced. Fixes for the Structure.test_superimpose_fit_to_mean system test for the displace_id argument. Modified the Structure.test_align_molecules system test to catch a bug. This is the failure of the displace_id argument of the structure.align user function when the molecules argument is supplied - all atoms are being displaced instead of a subset. Fix for the displace_id and molecules arguments of the structure.align user function. The atom ID used for the translations and rotations is now properly constructed from the molecule names in the molecules list and the displace_id string. Changes for water in the PDB file created by the structure.write_pdb user function. The waters with the residue name 'HOH' are no longer output to HET records. Improvement for the structure.read_pdb user function. The helix and sheet secondary structure reading now takes the real_mol argument into account to avoid reading in too much information. Improvement for the merge argument of the structure.read_pdb user function. This argument is now overridden if the molecule to merge to does not exist. This allows the merge flag to be used together with read_mol and set_mol_name set to lists. Fix for the selective secondary structure reading of the structure.read_pdb user function. The molecule index needs to incremented by 1 to be the molecule number. Large improvement for the PDB molecule identification code. This affects the structure.read_pdb user function. Now the chain ID code, if present in the PDB file, is being used to determine which ATOM and HETATM records belong to which molecule. All of the records for each molecule are stored until the end, when they are all yielded. This allows for discontinuous chain IDs throughout the PDB file, something which occurs often with the HETATM records. Expanded the displace_id argument for the structure.align user function. This can now be a list of atom IDs, so that any atoms can be rotated together with the structure being aligned. This is useful if the molecules argument is supplied. Fix for the Noe.test_bug_21562_noe_replicate_fail system test. This is for the changed behaviour of the structure.read_pdb user function. The problem is that the PDB file read in this test has the chain ID set to X. This broken PDB causes molecule numbering problems. Expanded the description of the structure.rmsd user function. Changed the paragraph ordering in the documentation of a number of the structure user functions. This includes the structure.align, structure.displacement, and structure.find_pivot user functions. Fix for the prompt examples documentation for the structure.align user function. Improved the sizing layout of the structure.align user function GUI dialog. Improved the sizing layout of the structure.superimpose user function GUI dialog. Created the Structure.test_atomic_fluctuations system test. This will be used to implement the idea of the structure.atomic_fluctuations user function. Implemented the structure.atomic_fluctuations user function. This is loosely based on the structure.web_of_motion user function and is related to it. The user function will write to file a correlation matrix of interatomic distance fluctuations. Created 4 unit tests for the lib.io.swap_extension function. This is in preparation for implementing the function. Implemented the lib.io.swap_extension() function. This is confirmed to be fully functional by its four unit tests. Created the empty lib.plotting package. This follows from this thread. The package will be used for assembling all of the data plotting capabilities of relax. It will make support for different plotting software - Grace, OpenDX, matplotlib, gnuplot, etc - more coherent. This will be used to create a software independent API for plotting in relax. I.e. the plotting software is chosen by the user and then the data output by the user function passes into the lib.plotting API which is then passed into the software dependent backend in lib.plotting. Created the Structure.test_atomic_fluctuations_gnuplot system test. This checks the operation of the structure.atomic_fluctuations user function when the output format is set to 'gnuplot'. This will be used to implement this option. The current gnuplot script expected by this test is just a very basic starting script for now. Created the lib.plotting API function correlation_matrix(). This is the lib.plotting.api.correlation_matrix() function. It will be used for the visualisation of rank-2 correlation matrices. The current basic API design here uses a dictionary of backend functions (currently empty) for calling the backend. Implemented a very basic gnuplot backend for the correlation_matrix() plotting API function. This is in the new lib.plotting.gnuplot module. It creates an incredibly basic gnuplot script for visualising the correlation matrix, assuming a text file has already been created. Enabled the gnuplot format for the structure.atomic_fluctuations user function. This uses the plotting API correlation_matrix() function for visualisation. The change allows the Structure.test_atomic_fluctuations_gnuplot system test to pass. Shifted the matrix output of the structure.atomic_fluctuations user function into lib.plotting.text. The new lib.plotting.text module will be used by the relax library plotting API to output data into plain text format. The current correlation_matrix() function, which has been added to the API correlation_matrix() function dictionary, simply has the file writing code of the structure.atomic_fluctuations user function. This significantly simplifies the user function. More simplifications for the structure.atomic_fluctuations user function backend. Fix for the structure.atomic_fluctuations user function backend. The pipe_control.structure.main.atomic_fluctuations() function no longer opens the output file. The gnuplot correlation_matrix() plotting API function now creates a text file of the data. The lib.plotting.gnuplot.correlation_matrix() function now calls the lib.plotting.text.correlation_matrix() function prior to creating the gnuplot script. Significantly expanded the gnuplot script from via the correlation_matrix() plotting API function. This is for the structure.atomic_fluctuations user function. The output terminal is now set to EPS, the colour map changed from the default to a blue-red map, labels have been added, the plot is now square, and comments are now included throughout the script to help a user hand modify it after creation. Improvement in the comments from the gnuplot correlation_matrix() plotting API function. Updated the Structure.test_atomic_fluctuations_gnuplot system test. This is for the gnuplot correlation_matrix() plotting API changes which affect the structure.atomic_fluctuations user function. Docstring fixes for the Structure.test_atomic_fluctuations_gnuplot system test. This was pointing to the structure.rmsd user function instead of structure.atomic_fluctuations. Fixes and improvements for the gnuplot correlation_matrix() plotting API function. This is for the structure.atomic_fluctuations user function. The "pm3d map" plot type is incorrect for such data type, so instead of using 'splot', 'plot' is being used instead. The resultant EPS file is now much smaller. The colour map has also been changed to one of the inbuilt ones for higher contrast. Forced the gnuplot correlation_matrix plot to be square. This is for the correlation_matrix() plotting API function used by the new structure.atomic_fluctuations user function. Updated the Structure.test_atomic_fluctuations_gnuplot system test. This is for the changes of the gnuplot correlation_matrix() plotting API function used by the structure.atomic_fluctuations user function. Docstring fix for the Structure.test_atomic_fluctuations system test. Another docstring fix for the Structure.test_atomic_fluctuations system test. Created the Structure.test_atomic_fluctuations_angle system test. This will be used to implement the mapping of inter-atomic vector angular fluctuations between structures via a new 'measure' keyword argument for the structure.atomic_fluctuations user function. Implemented angular fluctuations for the structure.atomic_fluctuations user function. This adds the measure argument to the user function to allow either the default of 'distance' or the 'angle' setting to be chosen. The implementation is confirmed by the Structure.test_atomic_fluctuations_angle system test which now passes. Clean ups and speed ups of the structure.atomic_fluctuations user function. Duplicate calculations are now avoided, as the SD matrix is symmetric. Description improvements and GUI layout fixes for the structure.atomic_fluctuations user function. Added the 'parallax shift' measure to the structure.atomic_fluctuations user function. The parallax shift is defined as the length of the average vector minus the interatomic vector. It is similar to the angle measure however, importantly, it is independent of the distance between the two atoms. Updated the gnuplot scripts to be executable. These are the scripts created by the gnuplot specific correlation_matrix() plotting API function. The file is made executable and the script now starts with "#!/usr/bin/env gnuplot". Created the Structure.test_atomic_fluctuations_parallax system test. This is to demonstrate that the parallax shift fluctuations are not implemented correctly. Fix for the Structure.test_atomic_fluctuations_parallax system test. The distance shifts need to be numbers, not vectors. Proper implementation of the 'parallax shift' for the structure.atomic_fluctuations user function. Improved the structure.atomic_fluctuations user function documentation. The fluctuation categories are now better explained. And the 'parallax shift' option is now available in the GUI. Fix for the parallax shift description in the structure.atomic_fluctuations user function. The parallax shift is not quite orthogonal to the distance fluctuations. Implemented ordinary_least_squares function the repeated auto-analysis. Inspection of statistics books, shows that several authors does not recommend using regression through the origin (RTO). From Joseph G. Eisenhauer, Regression through the Origin: RTO residuals will usually have a nonzero mean, because forcing the regression line through the origin is generally inconsistent with the best fit; R square measures (for RTO) the proportion of the variability in the dependent variable "about the origin" explained by regression. This cannot be compared to R square for models which include an intercept. From "Experimental design and data analysis for biologists", G. P. Quinn, M. J. Keough: Minimum observed xi rarely extends to zero, and forcing our regression line through the origin not only involves extrapolating the regression line outside our data range but also assuming the relationship is linear outside this range (Cade & Terrell 1997, Neter et al. 1996); We recommend that it is better to have a model that fits the observed data well than one that goes through the origin but provides a worse fit to the observed data; residuals from the no-intercept model no longer sum to zero; usual partition of SSTotal into SSRegression and SSResidual does not work. Added save state for test of bug 23186. Bug #23186: Error calculation of individual parameter δω from Monte-Carlo, is based on first spin. Added the system test Relax_disp.test_bug_23186_cluster_error_calc_dw which shows the failure of Monte Carlo simulations error calculations. Bug #23186: Error calculation of individual parameter δω from Monte-Carlo, is based on first spin. Added additional test for the r2a parameter. Bug #23186: Error calculation of individual parameter δω from Monte-Carlo, is based on first spin. Attempt to implement the GUI test General.test_bug_23187_residue_delete_gui. This will NOT catch the error. Bug #23187: Deleting residue in GUI, and then open spin viewer crashes relax. Added test for spin independent error of kAB. Bug #23186: Error calculation of individual parameter δω from Monte-Carlo, is based on first spin. Fix for the showing of the spin viewer window in the GUI tests. The show_tree() method of the main GUI window class was not calling the custom self.spin_viewer.Show() method, as required to set up the observer objects required to keep the spin viewer window updated. The value of status.show_gui was blocking this. Instead the show argument of this Show() method is being set to status.show_gui to allow the method to always be executed. Updated the main relax copyright notices for 2015. The copyright notice in the GUI now uses the info box object. This is for the status bar at the bottom of the GUI window. This removes one place where copyright notices needs to be updated each year. This status text will then be updated whenever the info.py file has been updated. Updated the copyright notice for 2015 in the GUI splash screen graphic. Racing fixes for the General.test_bug_23187_residue_delete_gui GUI test. Some GUI interpreter flush() calls have been added to avoid racing in the GUI. The GUI tests are so quick that the asynchronous user function call will be processed at the same time as the spin viewer window is being created, causing fatal segmentation faults in the test suite. More robustness for the spin viewer GUI window prune_*() methods. When no spin data exists, the self.tree.GetItemPyData(key) call can return None. This is now being checked for and such None values are being skipped in the prune_mol(), prune_res() and prune_spin() methods. The problem was found in the Mf.test_bug_20479_gui_final_pipe system test when running the command: for i in {1..10}; do ./relax --gui-tests --time -d &>> gui_tests.log; done More robustness for the spin viewer GUI window update_*() methods. When no spin data exists, the self.tree.GetItemPyData(key) call can return None. This is now being checked for and such None values are being skipped in the update_mol(), update_res() and update_spin() methods. The problem was found in the Mf.test_bug_20479_gui_final_pipe system test when running the command: for i in {1..10}; do ./relax --gui-tests --time -d &>> gui_tests.log; done More robustness for the spin viewer GUI window prune_*() methods. The data returned from the self.tree.GetItemPyData(key) call can in rare racing cases not contain the 'id' key. This is now being checked for and are being skipped in the prune_mol(), prune_res() and prune_spin() methods. The problem was found in the Mf.test_bug_20479_gui_final_pipe system test when running the command: for i in {1..10}; do ./relax --gui-tests --time -d &>> gui_tests.log; done More robustness for the spin viewer GUI window update_*() methods. The data returned from the self.tree.GetItemPyData(key) call can in rare racing cases not contain the 'id' key. This is now being checked for and are being skipped in the update_mol(), update_res() and update_spin() methods. The problem was found in the Mf.test_bug_20479_gui_final_pipe system test when running the command: for i in {1..10}; do ./relax --gui-tests --time -d &>> gui_tests.log; done Created a development document for catching segfaults and other errors in the GUI tests. This is needed as not all wxPython errors can be caught in the Python unittest framework. Small whitespace formatting fix for the titles printed by the align_tensor.display user function. Improvements for the plots created by the pcs.corr_plot user function. The axes now have labels, and have the range and number of ticks set to reasonable values. Improvements for the pcs.corr_plot user function - the plot range is now determined by the data. Improvements for the rdc.corr_plot user function - the plot range is now determined by the data. Added save state for testing implementation of error analysis. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Simplification of system test Relax_disp.test_task_7882_monte_carlo_std_residual, to just test the creation of Monte-Carlo data where errors are drawn from the reduced χ2 distribution. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Extension of the monte_carlo.create_data user function to draw errors from the reduced χ2 Gauss distribution as found by best fit. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Adding to backend of pipe_control.error_analysis(), to modify data point as error drawn from the reduced χ2 Gauss distribution. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Adding empty API method to return errors from the reduced χ2 distribution. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Added API function in relaxation dispersion to return error structure from the reduced χ2 distribution. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Temporary test of making a confidence interval as described in fitting guide. This is system test Relax_disp.x_test_task_7882_kex_conf, which is not activated by default. Running the test, interestingly shows, there is a possibility for a lower global kex. But the value only differ from kex=1826 to kex=1813. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Change to system test Relax_disp.x_test_task_7882_kex_conf(). This is just a temporary system test, to check for local minima. This is method in regression book of Graphpad: http://www.graphpad.com/faq/file/Prism4RegressionBook.pdf Page: 109-111. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Raising an error, if the R2eff model is used, and drawing errors from the fit. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. To system test Relax_disp.test_task_7882_monte_carlo_std_residual(), adding test for raise of errors, if the R2eff model is selected. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Added test of argument "distribution" in pipe_control.error_analysis.monte_carlo_create_data(). This is to make sure that a wrong argument is not passed into the function. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Extended the monte_carlo.create_data user function, to allow for the definition of the STD to use in Gauss distribution. This is for creation of Monte-Carlo simulations, where one has perhaps gained information about the expected errors of the data points, which is not measured. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. In backend pipe_control.error_analysis.monte_carlo_create_data() added the argument 'fixed_error' to allow for fixed input of error to the Gauss distribution. Inserted a range of checks, to make sure function behaves as expected. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Added to pipe_control.error_analysis.monte_carlo_create_data() the creation of data points for a fixed distribution. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. To system test Relax_disp.test_task_7882_monte_carlo_std_residual(), added tests for creation of Monte-Carlo data by different methods. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. In pipe_control.error_analysis.monte_carlo_create_data(), if data is of list type or ndarray, then modify the data point according to the fixed error if the distribution is set to 'fixed'. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Expanded the STD acronym, to the meaning of standard deviation. This is in the monte_carlo.create_data user function. Task #7882: Implement Monte-Carlo simulation whereby errors are generated with width of standard deviation or residuals. Added a RelaxWarning printout to the dep_check module if wxPython 2.8 or less is encountered. This follows from http://thread.gmane.org/gmane.science.nmr.relax.devel/7502. The warning text is simply written to STDERR as relax starts. Updated the wxPython version in the relax manual to be 2.9 or higher. This is in the section http://www.nmr-relax.com/manual/Dependencies.html. The GUI tests are now skipped for wxPython version <= 2.8 due to bugs causing fatal segfaults. This follows from http://thread.gmane.org/gmane.science.nmr.relax.devel/7502. These wxPython versions are simply too buggy. Fix for the Relax_disp.test_bug_23186_cluster_error_calc_dw system test on 32-bit and Python <= 2.5 systems. Better error handling in the structure.align user function. If no common atoms can be found between the structures, a RelaxError is now raised for better user feedback. Created an empty lib.sequence_alignment relax library package. This may be used in the future for implementing more advanced structural alignments (the current method is simply to skip missing atoms, sequence numbering changes are not handled). Added the sequence_alignment package to the lib package __all__ list. Added the unit testing infrastructure for the new lib.sequence_alignment package. Implementation of the Needleman-Wunsch sequence alignment algorithm. This is located in the lib.sequence_alignment.needleman_wunsch module. This is implemented as described in the Wikipedia article https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm. Created a unit test for checking the Needleman-Wunsch sequence alignment algorithm. This uses the DNA data from the example in the Wikipedia article at https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm. The test shows that the implementation of the lib.sequence_alignment.needleman_wunsch.needleman_wunsch_align() function is correct. Created the lib.sequence_alignment.substitution_matrices module. This is for storing substitution matrices for use in sequence alignment. The module currently only includes the BLOSSUM62 matrix. Corrected the spelling of the BLOSUM62 matrix in lib.sequence_alignment.substitution_matrices. Fix for the lib.sequence_alignment.substitution_matrices.BLOSUM62_SEQ string. Modification of the Needleman-Wunsch sequence alignment algorithm implementation. This is in the lib.sequence_alignment.needleman_wunsch functions. Scoring matrices are now supported, as well as a user supplied non-integer gap penalty. The algorithm for walking through the traceback matrix has been fixed for a bug under certain conditions. Created the lib.sequence_alignment.align_protein module for the sequence alignment of proteins. This general module currently implements the align_pairwise() function for the pairwise alignment of protein sequences. It provides the infrastructure for specifying gap starting and extension penalties, choosing the alignment algorithm (currently only the Needleman-Wunsch sequence alignment algorithm as 'NW70'), and choosing the substitution matrix (currently only BLOSUM62). The function provides lots of printouts for user feedback. Created a unit test for lib.sequence_alignment.align_protein.align_pairwise(). This is to test the pairwise alignment of two protein sequences using the Needleman-Wunsch sequence alignment algorithm, BLOSUM62 substitution matrix, and gap penalty of 10.0. Added more printouts to the Test_align_protein.test_align_pairwise unit test. This is the test of the module _lib._sequence_alignment.test_align_protein. Fix for the Needleman-Wunsch sequence alignment algorithm when the substitution matrix is absent. The lib.sequence_alignment.align_protein.align_pairwise() function now returns data. This includes both alignment strings as well as the gap matrix. Annotated the BLOSUM62 substitution matrix with the amino acid codes for easy reading. Updated the gap penalties in the Test_align_protein.test_align_pairwise unit test. This is from the unit test module _lib._sequence_alignment.test_align_protein. Modified the Needleman-Wunsch sequence alignment algorithm. The previous attempt was buggy. The algorithm has been modified to match the logic of the GPL licenced EMBOSS software to allow for gap opening and extension penalties, as well as end penalties. No code was copied, rather the algorithm for creating the scoring and penalty matrices, as well as the traceback matrix. Added a DNA similarity matrix to lib.sequence_alignment.substitution_matrices. Added sanity checks to the Needleman-Wunsch sequence alignment algorithm. The residues of both sequences are now checked in needleman_wunsch_align() to make sure that they are present in the substitution matrix. Added the NUC 4.4 nucleotide substitution matrix from ftp://ftp.ncbi.nih.gov/blast/matrices/. Uracil was added to the table as a copy to T. Added the header from ftp://ftp.ncbi.nih.gov/blast/matrices/BLOSUM62. This is to document the BLOSUM62 substitution matrix. Added the PAM 250 amino acid substitution matrix. This was taken from ftp://ftp.ncbi.nih.gov/blast/matrices/PAM250 and added to lib.sequence_alignment.substitution_matrices.PAM250. Modified the Test_needleman_wunsch.test_needleman_wunsch_align_DNA unit test to pass. This is from the unit test module _lib._sequence_alignment.test_needleman_wunsch. The DNA sequences were simplified so that the behaviour can be better predicted. Created the Test_needleman_wunsch.test_needleman_wunsch_align_NUC_4_4 unit test. This is in the unit test module _lib._sequence_alignment.test_needleman_wunsch. This tests the Needleman-Wunsch sequence alignment for two DNA sequences using the NUC 4.4 matrix. Created a unit test for demonstrating a failure in the Needleman-Wunsch sequence alignment algorithm. The test is Test_needleman_wunsch.test_needleman_wunsch_align_NUC_4_4b from the _lib._sequence_alignment.test_needleman_wunsch module. The problem is that the start of the alignment is truncated if any gaps are present. Fix for the Needleman-Wunsch sequence alignment algorithm. The start of the sequences are no longer truncated when starting gaps are encountered. The needleman_wunsch_align() function now accepts the end gap penalty arguments. These are passed onto the needleman_wunsch_matrix() function. Added the end gap penalty arguments to lib.sequence_alignment.align_protein.align_pairwise(). Created the Structure.test_align_CaM_BLOSUM62 system test. This will be used for expanding the functionality of the structure.align user function to perform true sequence alignment via the new lib.sequence_alignment package. The test aligns 3 calmodulin (CaM) structures from different organisms, hence the sequence numbering is different and the current structure.align user function design fails. The structure.align user function has been expanded in the test to include a number of arguments for advanced sequence alignment. Added support for the PAM250 substitution matrix to the protein pairwise sequence alignment function. This is the function lib.sequence_alignment.align_protein.align_pairwise(). Bug fix for the Needleman-Wunsch sequence alignment algorithm. Part of the scoring system was functioning incorrectly when the gap penalty scores were non-integer, as some scores were being stored in an integer array. Now the array is a float array. Created the Test_align_protein.test_align_pairwise_PAM250 unit test. This is in the unit test module _lib._sequence_alignment.test_align_protein. It checks the protein alignment function lib.sequence_alignment.align_protein.align_pairwise() together with the PAM250 substitution matrix. Small docstring expansion for lib.sequence_alignment.align_protein.align_pairwise(). Added the sequence alignment arguments to the structure.align user function front end. This includes the 'matrix', 'gap_open_penalty', 'gap_extend_penalty', 'end_gap_open_penalty', and 'end_gap_extend_penalty' arguments. The 'algorithm' argument has not been added to save room, as there is only one choice of 'NW70'. A paragraph has been added to the user function description to explain the sequence alignment part of the user function. Added the sequence alignment arguments to the back end of the structure.align user function. This is to allow the code in trunk to be functional before the sequence alignment before superimposition has been implemented. Removed the 'algorithm' argument from the Structure.test_align_CaM_BLOSUM62 system test script. This is for the structure.align user function. The argument has not been implemented to save room in the GUI, and as 'NW70' is currently the only choice. The sequence alignment arguments are now passed all the way to the internal structural object backend. These are the arguments of the structure.align user function. Created the lib.sequence.aa_codes_three_to_one() function. The lib.sequence module now contains the AA_CODES dictionary which is a translation table for the 3 letter amino acid codes to the one letter codes. The new aa_codes_three_to_one() function performs the conversion. Implemented the internal structural object MolContainer.loop_residues() method. This generator method is used to quickly loop over all residues of the molecule. Implemented the internal structural object one_letter_codes() method. This will create a string of one letter residue codes for the given molecule. Only proteins are currently supported. This method uses the new lib.sequence.aa_codes_three_to_one() relax library function. Sequence alignment is now performed in lib.structure.internal.coordinates.assemble_coord_array(). This is a pairwise alignment to the first molecule of the list. The alignments are not yet used for anything. The assemble_coord_array() function is used by the structure.align user function, as well as a few other structure user functions. Fix for the lib.sequence.aa_codes_three_to_one() function. Non-standard residues are now converted to the '*' code. The value of 'X' prevents any type of alignment of a stretch of X residues as X to X in both the BLOSUM62 and PAM250 substitution matrices are set to -1. Modified the gap penalty arguments for the structure.align user function. These now must always be supplied, as None is not handled by the backend lib.sequence_alignment.needleman_wunsch module. The previous defaults of None are now set to 0.0. Updated the artificial diffusion tensor test suite data. This is the data in test_suite/shared_data/diffusion_tensor. The residues in the PDB files are now proper amino acids, so the HETATM records are now ATOM records, and the CONECT records have been eliminated. Another update for the artificial diffusion tensor test suite data. The number of increments on the sphere has been increased from 5 to 6, to make the vector distribution truly uniform. All PDB files and relaxation data has been updated. Changed the synthetic PDB for the artificial diffusion tensor test suite data. The nitrogen and proton positions are now shifted 10 Angstrom along the distribution vectors. This is to avoid having all nitrogens positioned at the origin which causes the internal structural object algorithm for determining which atoms are connected to fail. Reintroduced the CONECT PDB records into the artificial diffusion tensor test suite data. The uniform vector distributions have overlapping vectors. This causes the internal structural object atom connection determining algorithm to fail, as this is distance-based rather than using the PDB amino acid definitions for now. Updates for the Structure.test_create_diff_tensor_pdb_sphere system test. The test now uses the sphere synthetic relaxation data rather than the ellipsoid data, and the PDB checking has been updated for the new data. Updates for the Structure.test_create_diff_tensor_pdb_prolate system test. The test now uses the spheroid synthetic relaxation data rather than the ellipsoid data, and the PDB checking has been updated for the new data. Updates for the Structure.test_create_diff_tensor_pdb_oblate system test. The test now uses the spheroid synthetic relaxation data rather than the ellipsoid data, and the PDB checking has been updated for the new data. The oblate tensor is now forced in the system test script. Updates for the Structure.test_create_diff_tensor_pdb_ellipsoid system test. The PDB checking has been updated for the new data. Updated the Structure.test_delete_atom system test for the changed PDB structures. The test_suite/shared_data/diffusion_tensor/spheroid/uniform.pdb file now has more residues, and the atomic positions are different. Updated the Structure.test_align system test for the changed PDB structures. The test_suite/shared_data/diffusion_tensor/spheroid/uniform.pdb file now has more residues, and the atomic positions are different. Updated the Structure.test_align_molecules system test for the changed PDB structures. The test_suite/shared_data/diffusion_tensor/spheroid/uniform.pdb file now has more residues, and the atomic positions are different. Python 3 fix for the lib.sequence module. The string.upper() function no longer exists. Python 3 fix for the lib.sequence_alignment.align_protein module. The string.upper() function no longer exists. Modified the generate_data.py diffusion tensor to relaxation data creation script. The NH vectors are no longer truncated to match the PDB. Python 3 fix for the generate_data.py diffusion tensor to relaxation data creation script. The string.upper() function no longer exists. Reintroduced the simulated PDB truncation into the artificial diffusion tensor test suite data. This is different to the previous implementation which was deleted recently. It now simulates the truncation of both the N and H positions in the PDB and reconstructs the expected vector. Updates for some of the Structure.test_create_diff_tensor_pdb_* system tests. This includes Structure.test_create_diff_tensor_pdb_ellipsoid, Structure.test_create_diff_tensor_pdb_oblate, and Structure.test_create_diff_tensor_pdb_prolate. The new simulated PDB truncation in the test data causes the PDB files created in these tests to be slightly different. The pairwise sequence alignment is now active in the structure.align user function. This is implemented in the lib.structure.internal.coordinates.assemble_coord_array() function for assembling atomic coordinates. It will also automatically be used by many of the structure user functions which operate on multiple structures. The atomic coordinate assembly logic has been completely changed. Instead of grouping atomic information by the molecule, it is now grouped per residue. This allows the residue based sequence alignments to find matching coordinate information. The assemble_coord_array() function will also handle the algorithm argument set to None and assume that the residue sequences are identical between the structures, but this should be avoided. A new function, common_residues() has been created as a work-around for not having a multiple sequence alignment implementation. It will take the pairwise sequence alignment information and construct a special data structure specifying which residues are present in all structures. The logic for skipping missing atoms remains in place, but it now operates on the residue rather than molecule level and simply uses the atom name rather than atom ID to identify common atoms. Changed the gap opening penalty to 10 in the N-state model structure_align.py system test script. Docstring update for the pipe_control.structure.main.assemble_coordinates() function. This is for the algorithm argument which can now be set to None. Fix for the sequence alignment for assembling atomic coordinates. This caused the Structure.test_superimpose_fit_to_mean system test to fail. The problem was in the new logic of the lib.structure.internal.coordinates.assemble_coord_array() function. The coordinate assembly now terminates when either the end of the first molecule or the current molecule is reached. Bug fixes for the new lib.structure.internal.coordinates.common_residues() function. This function for determining the common residues between multiple sets of pairwise alignments was failing in quite a number of cases. The logic has been updated to handle these. Another fix for the lib.structure.internal.coordinates.common_residues() function. The wrong index was being used to skip residues in the second sequence. Created the Structure.test_pdb_combined_secondary_structure system test. This is used to demonstrate a problem in the handling of secondary structure metadata when combining multiple PDB structures. It appears as if the chain ID is preserved as the original ID and is not updated to match the new IDs in the output PDB. Updated the Structure.test_metadata_xml system test for the changed PDB metadata handling. The helix and sheets IDs are now molecule indices. Disabled the General.test_bug_23187_residue_delete_gui GUI test. This is essential as a wxPython bug in Mac OS X systems causes this test to trigger a 'Bus Error' every time the GUI tests are run, killing relax. relax 3.3.4 Small updates for the wiki section of the release checklist document. Fixes for the links at the bottom of all HTML manual pages. This is for the automatically generated documentation, created using latex2html. The links all require double quotes, and some a trailing '/'. The links fixed are [1], [2] and [3]. Removed the repository backup file text from the relax manual. The gzipped repository dump file has not been created by Gna! for many, many years. The problem was identified by the W3C link checker. Updated all of the [4] links in the lib.dispersion package. This is for all of the individual model pages in the HTML manual. Improved the description for the relax_fit.select_model user function. A small code rearrangement to create the new target_functions.relax_fit_wrapper module. This follows from the idea at https://web.archive.org/web/gna.org/task/?7415#comment6. The *func_wrapper() functions of the specific_analyses.relax_fit.optimisation module have been shifted out and converted to class methods to create the target_functions.relax_fit_wrapper module. This will be used to abstract away all of the C code, and will form the infrastructure to allow new exponential curves to be quickly supported. The modules of the specific_analyses.relax_fit and specific_analyses.relax_disp packages now import the target_functions.relax_fit_wrapper.Relax_fit_opt target function class and use that instead. Shifted the C code Jacobian functions into the new target_functions.relax_fit_wrapper module. This shifts all of the relaxation curve-fitting C code access into the target_functions.relax_fit_wrapper module so that the rest of relax does not need to handle the C code. This will allow for new models to be very easily supported, as they would all be set up in this target function module. Updated the formula in the description of the relax_fit.select_model user function. Modified the printouts from the structure.write_pdb user function if models are present. Instead of printing out 'MODEL', 'ATOM, HETATM, TER' and 'ENDMDL' for each model, the header 'MODEL records' is printed followed by a single '.' character for each model. For structures with many models, this results in a huge speed up of the user function which is strongly limited by how fast the terminal can display text. Added the synthetic saturation-recovery data in the form of Sparky peak lists to the repository. These files were created by Andras Boeszoermenyi. They are attached to Task #7415 as the Relax_sym.tar.gz file. They were created for the formula I0(1 - e−R1.t) where I0 = 1000000000000000.00 and R1 = 0.5. These files and the associated relax_sim.py script (which needs to be updated for the latest relax version) could form the basis of a basic system test. This system test could then be used to implement the saturation-recovery experiment equations in relax. Updated the target_functions package __all__ list to include the relax_fit* modules. Modified the package __all__ list checking unit test to accept *.so C modules. Removal of an unused import in the relax_fit_zooming_grid.py system test script. Added a system test script for testing the saturation-recovery R1 experiment. This was created by Andras Boeszoermenyi. The file was taken from the saturation_recovery.tar.gaz file attached to Task #7415. The only difference with the original script is that the grace.view user function calls have been removed, as these cannot be used in a system test. Modified the relax_fit_saturation_recovery.py script to work as a system test. This is the script from Andras Boeszoermenyi. The change follows from the discussion of [5]. The status.install_path variable is now used to point to the location of the files. The relax data store ds.tmpdir variable is used for outputting all files. And commented out user functions have been deleted. Added a copyright notice for Andras Boeszoermenyi for the newly added saturation-recovery R1 script. This change follows the discussion in the message [6]. Created the Relax_fit.test_saturation_recovery system test. This follows from the discussion of [7]. Added the saturation recovery experiment to the relax_fit.select_model user function. This simply adds a new option and sets up a different parameter set [Rx, I∞]. Modified the Relax_fit.test_saturation_recovery system test script. The relax_fit.select_model user function call now selects the 'sat' model. Fix for the relax_fit.select_model user function backend for the 'sat' model. The exponential model name is now being passed into the target function class. The model as specified by the relax_fit.select_model user function is now finally being sent into the target function, in this case the target_functions.relax_fit_wrapper.Relax_fit_opt Relax_fit_opt class in target_functions.relax_fit_wrapper. Small fix for the relax_fit.select_model user function. Renamed all of the relaxation curve-fitting target functions. This includes all of the C functions which are model specific, by appending '_exp' to the current names to now be func_exp, dfunc_exp, http://www.nmr-relax.com/api/3.3/target_functions.relax_fit-module.html#d2func_exp d2func_exp], jacobian_exp, and jacobian_chi2_exp. And all of the target_functions.relax_fit_wrapper.Relax_fit_opt Relax_fit_opt target function class *_wrapper() methods to *_exp(). The target function class is now only aliasing the *_exp() methods when the model is set to 'exp'. Alphabetical ordering of the C function imports in the target_functions.relax_fit_wrapper module. Modified the Relax_fit.test_saturation_recovery system test to check for I∞ instead of I0. Added support for the saturation recovery experiment to parameter disassembly function. This is in the disassemble_param_vector() function of the specific_analyses.relax_fit.parameters module. This function requires each experiment to be handled separately. Implemented the target functions for the saturation recovery exponential curve. In the target_functions.relax_fit_wrapper.Relax_fit_opt Python target function class Relax_fit_opt, the new func_sat(), dfunc_sat() and d2func_sat() methods have been created as wrappers for the new C functions. These are aliased to func(), dfunc() and d2func() in the __init__() method. In the target_functions/exponential.c C file, the functions exponential_sat(), exponential_sat_dIinf(), exponential_sat_dR(), exponential_sat_dIinf2(), exponential_sat_dR_dIinf() and exponential_sat_dR2() have been created to implement the function, gradient, and Hessian for the equation I(t) = I∞(1 - e-R.t). In the target_functions/relax_fit.c file, the functions func_sat(), dfunc_sat(), d2func_sat(), jacobian_sat() and jacobian_chi2_sat() have been created as duplications of the *_exp() functions, but pointing to the exponential_sat*() functions and using I∞ instead of I0. Split the saturation recovery exponential equations and partial derivatives into their own C file. Expansion and improvements for the relax_fit.select_model user function documentation and printouts. The relax_fit.relax_time and relax_fit.select_model user functions now have wizard graphics. The R1 graphic from graphics/analyses/r1_200x200.png is now being used. Added support for the inversion recovery experiment to parameter disassembly function. This matches the change for the saturation recovery experiment. This is in the disassemble_param_vector() function of the specific_analyses.relax_fit.parameters module. This function requires each experiment to be handled separately. Expanded the relax_fit_saturation_recovery.py system test script. This now calls the error_analysis.covariance_matrix user function to test that code path. Updated the relaxation curve-fitting covariance_matrix() API method to handle all models. The check for the 'exp' model type has been eliminated, and the parameter vector is assembled using the flexible assemble_param_vector() function rather than manually constructing the vector. The errors in the Relax_fit.test_saturation_recovery system test are now reasonable. They have been set to 5% of I∞ so that the chi-squared value during optimisation is more realistic. Updated the relaxation curve-fitting get_param_names() API method to handle all models. This now simply returns the spin container 'params' list, allowing all models to be properly supported. Big bug fix for the error_analysis.covariance_matrix user function. The model_info structure is now being passed into the get_param_names() API method, as required by the API. Another change for the relaxation curve-fitting covariance_matrix() API method to handle all models. The scaling matrix diagonalised list of 1.0 values now has the same number of elements as there are parameters. Implemented the target functions for the inversion recovery exponential curve. In the target_functions.relax_fit_wrapper.Relax_fit_opt Python target function class Relax_fit_opt, the new func_inv(), dfunc_inv() and d2func_inv() methods have been created as wrappers for the new C functions. These are aliased to func(), dfunc() and d2func() in the __init__() method. The target_functions/exponential_inv.c C file has been created with the functions exponential_inv(), exponential_inv_d0(), exponential_inv_dIinf(), exponential_inv_dR(), exponential_inv_dI02(), exponential_inv_dIinf2(), exponential_inv_dI0_dIinf(), exponential_inv_dR_dI0(), exponential_inv_dR_dIinf() and exponential_inv_dR2() have been created to implement the function, gradient, and Hessian for the equation I(t) = I∞ - I0e-R.t. In the target_functions/relax_fit.c file, the functions func_inv(), dfunc_inv(), d2func_inv(), jacobian_inv() and jacobian_chi2_inv() have been created as duplications of the *_exp() functions, but pointing to the exponential_inv*() functions and adding the I∞ dimension. More editing of the relax_fit.select_model user function. The IR and SR abbreviations have been added, and a lot of text cleaned up. Improvement for the relax_fit.select_model user function in the GUI. Unicode text is now being used to display the parameters as R_x and I_0 and to show an infinity symbol in the I∞ parameter. The Rx and I∞ parameters have been added to lib.text.gui to allow this. Expanded the relaxation curve-fitting chapter of the manual to include descriptions of the models. A new section at the start of this chapter has been added to explain the different models and their equations. This was taken from the script mode section and expanded to include the new saturation recovery experiment. Removed the relax_fit.select_model user function call from the relax_fit auto-analysis. This is to allow the user in a script, or in the GUI, to choose the model themselves. Added a button to the R1 and R2 GUI analyses for executing the relax_fit.select_model user function. This is just after the peak list GUI element and before the optimisation settings. It allows different curve types to be selected for the analysis. Created the new specific_analyses.relax_fit.checks module. This creates the check_model_setup Check object, following the check_*() function design at [8]. This will be used to make sure that the exponential curve model is set prior to executing certain user functions. Improved the checking in the relaxation curve-fitting analysis. The new specific_analyses.relax_fit.checks.check_model_setup() function is now called prior to minimisation and in the get_param_names() API method to prevent Python errors from occurring due to missing data structures. In addition, the pipe_control.mol_res_spin module function exists_mol_res_spin_data() has been replaced with check_mol_res_spin_data(). Fix for the recently broken Relax_fit.test_curve_fitting_height_estimate_error system test. The relax_fit.select_model user function is now called as this is no longer performed in the auto-analysis. Removed the text that the inversion recovery experiment is not implemented yet. This is in the documentation for the relax_fit.select_model user function and is in preparation for completing this. Added the checks module to the specific_analyses.relax_fit package __all__ list. Fixes for the relaxation dispersion analysis for the recent relaxation curve-fitting analysis changes. The target_functions.relax_fit_wrapper.Relax_fit_opt Relax_fit_opt target function class requires the model argument to be supplied to be correctly set up. Fixes for the unit tests of the target_functions.relax_fit C module. This is for the recent renaming of all the C functions based on the model type. Fix for the Rx.test_r1_analysis GUI test. A click on the relax_fit.select_model user function button is now being simulated. Created a directory for holding synthetic inversion recovery R1 data. Copied synthetic inversion recovery Sparky peak lists from Sébastien Morin's inversion-recovery branch. Created a system test script for the inversion-recovery function. This is based on a copy of the script 'relax_fit_exp_2param_neg.py'. The 3-parameter curve fitting test script now uses the corresponding peak lists. Prepared the "exp_3param" test for inclusion of artificial data. Added missing delays in the list. The duplicates had been omitted... Manually fix the script based on changes made during branch updating. This is as discussed by Edward d'Auvergne in a post at [9]. Updated Séb's relax_fit_exp_3param_inv_neg.py system test script to work with the current relax design. Added a script for calculating the expected peak intensities for an inversion recovery curve. This is based on the values used by Sébastien Morin in his inversion-recovery branch, as the check_curve_fitting_exp_3param_inv_neg() function of the test_suite/system_tests/relax_fit.py file. Increased the precision of the printout from the calc.py script of the last commit. Changed the peak intensities for Gly 4 in the synthetic inversion recovery Sparky lists. The values have been changed to match that determined from the calc.py script. The replicate spectra intensities are simply the calculated intensity +/-1, to preserve the average. Created the Relax_fit.test_inversion_recovery system test. This simply calls Sébastien Morin's relax_fit_exp_3param_inv_neg.py system test script, ported from the inversion-recovery branch, and then checks the parameter values for the single optimised spin. Updated the manual_c_module.py C module compilation development script for the recent changes. The exponential_inv.c and exponential_sat.c files need to be compiled as well. Python 3 fix for the relax_fit_exp_3param_inv_neg.py system test script. The xrange() function does not exist in Python 3, so was replaced by range(). Updated the memory_leak_test_relax_fit.py development script for the C module changes. This is only the docstring description which changed. Epydoc docstring fixes for the lib.io module - keyword arguments were not correctly identified. These were identified by Troels in the post at [10]. Created the State.test_bug_23017_ieee_754_multidim_numpy_arrays system test. This is to catch bug #23017, the multidimensional numpy arrays are not being stored as IEEE 754 arrays in the XML state and results files. This test checks a rank-2 float64 numpy array stored in the current data pipe against what the IEEE 754 int list should be for it. Grammar fix for a warning from the pymol.frame_order user function. relax 3.3.3 Basic Epydoc fix for the data_store.exp_info module. Epydoc fix for the name_pipe() method of the relaxation dispersion auto-analysis for repeated data Fixes for the HTML user manual compilation. The index.html file was not being created as the main page has changed from 'relax_user_manual.html' to 'The_relax_user_manual.html'. Added a line to the release checklist document about updating the wiki release links. These are for the combined release notes pages at Relax releases, Relax release descriptions, Relax release metadata, Relax release features, Relax release changes, Relax release bugfixes, Relax release links. Updates for the release announcement section of the release checklist document. Created a system test to catch a rare relaxation data loading problem. Created the Mf.test_dauvergne_protocol_sphere system test. This catches bug #22963: Using '@N*' to define the interatomic interactions for a model-free analysis fails when using non-backbone 15N spins. Set more reasonable default values for the lib.structure.pdb_write functions atom() and hetatm(). The occupancy now defaults to 1.0 instead of , and the temperature factor to 0.0 instead of . This avoid painful errors when using these functions, as these arguments must be floating point numbers at all times, hence the default value of causes a TypeError. Updated the PDB file in the test_suite/shared_data/model_free/sphere/ directory. The relax library is now being used to create the PDB file. Additional TER and CONECT records are now being created so the result is a more correct PDB file. Converted all ATOM records to HETATM in the sphere.pdb file. Renamed vector_angle() to vector_angle_normal() in the lib.geometry.vectors module. This is to standardise the naming as there are now the standard vector angle formula implemented as the vector_angle_acos() and vector_angle_atan2() functions. Added 6 unit tests for the lib.geometry.vectors.vector_angle_acos() function. These are similar to those of the vector_angle_normal() function but unsigned angles are checked for. Created 6 unit tests for the lib.geometry.vectors.vector_angle_atan2() function. Created a script and log file to demonstrate differences between alignment tensor basis sets. This shows that the inter-tensor angles and condition numbers are dependent on the basis set used. Improved the printouts from the align_tensor.svd user function by including the basis set text. Updated the log file for comparing different alignment tensor basis sets for align_tensor.svd changes. Implemented a new default basis set for the align_tensor.matrix_angles user function. This is uses standard definition of the inter-matrix angle using the Euclidean inner product of the two matrices divided by the product of the Frobenius norm of each matrix. As this is a linear map, it should produce the correct definition of inter-tensor angles. Improvements to the description of the align_tensor.matrix_angles user function. Updated the test_matrix_angles_identity() unit test for pipe_control.align_tensor.matrix_angles(). This is the test in the _prompt.test_align_tensor.Test_align_tensor module. The basis set has been set back to the now non-default value of 0, and the value checks have been converted from assertEqual() to assertAlmostEqual() to allow for small truncation errors. Conversion of the basis_set argument for the align_tensor.matrix_angles user function. The argument is now a string that accepts the values of 'matrix', 'unitary 5D', and 'geometric 5D' to select between the different matrix angles techniques. This has been updated in the test suite as well. Added a check for the values of the basis_set argument. This is to the align_tensor.matrix_angles user function backend. Printout improvements clarifying the align_tensor.matrix_angles user function. Conversion of the basis_set argument for the align_tensor.svd user function. The argument is now a string that accepts the values of 'unitary 9D', 'unitary 5D', and 'geometric 5D' to select between the different SVD matrices. This has been updated in the test suite as well. Expanded the N_state_model.test_5_state_xz system test. This now covers the new 'unitary 9D' basis set for the align_tensor.svd user function and the new 'matrix' basis set for the align_tensor.matrix_angles user function. Expansion of the align_tensor.matrix_angles user function. The new basis set 'unitary 9D' has been introduced. This creates vectors as {Sxx, Sxy, Sxz, Syx, Syy, Syz, Szx, Szy, Szz} and computes the inter-vector angles. These match the 'matrix' basis set whereby the Euclidean inner product divided by the Frobenius norms is used to calculate the inter-tensor angles. In addition, the user function documentation and printouts have been improved. And the backend code has been simplified. Updated the script and log file for demonstrating differences between alignment tensor basis sets. This now handles the changes to the basis_set arguments used in the align_tensor.matrix_angles and align_tensor.svd user functions, and includes the new basis sets. Added the irreducible tensor notation of {A-2, A-1, A0, A1, A2} to the alignment tensor object. This follows from the definition of Sass et al, J. Am. Chem. Soc. 1999, 121, 2047-2055, DOI: 10.1021/ja983887w. The equations of (2) were converted using Gaussian elimination to obtain a reduced row echelon form, so that the equations in terms of {A-2, A-1, A0, A1, A2} were derived. These have been coded into the alignment tensor object calc_Am2, calc_Am1, calc_A0, calc_A1 and calc_A2 methods respectively, and the values can be obtained by accessing the Am2, Am1, A0, A1, and A2 objects. To check that the implementation is correct, a unit test has been created to compare the calculated values with those determined using Pales. Expanded the unit test of the alignment tensor {A-2, A-1, A0, A1, A2} parameters to cover all values. Created functions in the relax library for calculating the inter-vector angle for complex vectors. This is in the lib.geometry.vectors module. The [function http://www.nmr-relax.com/api/3.3/lib.geometry.vectors-module.html#vector_angle_complex_conjugate vector_angle_complex_conjugate()] has been created to calculate the angle between two complex vectors. This uses the new auxiliary function complex_inner_product() to calculate <v1|v2>. Added the 'irreducible 5D' basis set option to the align_tensor.matrix_angles user function. This is for the inter-tensor vector angle for the irreducible 5D basis set {S-2, S-1, S0, S1, S2}. Its results match that of the standard tensor angle as well as the 'unitary 9D' basis sets. Added the 'irreducible 5D' basis set option to the align_tensor.svd user function. This is for the inter-tensor vector angle for the irreducible 5D basis set {A-2, A-1, A0, A1, A2}. Its results match that of the 'unitary 9D' basis set. Editing of the description for the 'irreducible 5D' alignment tensor basis set. This is for the align_tensor.matrix_angles and align_tensor.svd user functions. All Sm element have been converted to Am. Editing of the description for the align_tensor.matrix_angles user function. Editing of the align_tensor.svd user function description. Updated the script and log file for demonstrating differences between alignment tensor basis sets. The 'irreducible 5D' basis set in now used for both the align_tensor.matrix_angles and align_tensor.svd user functions. Fix for a spelling mistake in the align_tensor.matrix_angles user function printouts. Small fix for the align_tensor.matrix_angles user function documentation. Expanded the N_state_model.test_5_state_xz system test for more alignment tensor basis sets. The align_tensor.matrix_angles and align_tensor.svd user functions are now being called with the additional 'irreducible 5D', and 'unitary 9D' basis sets, to make sure these work correctly. Created the Align_tensor.test_align_tensor_matrix_angles system test. This is to check the angles calculated by the align_tensor.matrix_angles user function. As there are no external references, this essentially fixes the angles to the currently calculated values to catch any accidental changes in the future. Created the Align_tensor.test_align_tensor_svd system test. This is to check the angles calculated by the align_tensor.svd user function. As there are no external references, this essentially fixes the singular values and condition numbers to the currently calculated values to catch any accidental changes in the future. Fixes for the proportions of the align_tensor.matrix_angles user function GUI wizard. Expanded the 'irreducible 5D' text in the align_tensor.matrix_angles and align_tensor.svd user functions. This now explains that these are the coefficients for the spherical harmonic decomposition. Improved the text for the irreducible tensor notation in the align_tensor.display user function. Formatting fix for the magnetic susceptibility tensor part of the align_tensor.display user function. More improvements for the align_tensor.matrix_angles user function description. Epydoc docstring fixes and expansion for the lib.io.sort_filenames() function. Epydoc docstring fixes for the lib.spectrum.nmrpipe module. This is for the API documentation. The show_apod_rmsd_to_file() and show_apod_rmsd_dir_to_files() function docstrings have both been modified. Epydoc docstring fixes for the pipe_control.opendx.map() function. The fixes include whitespace and textwrapping changes. Python 2.5 fix for the align_tensor.display user function. The new irreducible spherical tensor coefficient printout was failing as the float.real variable was introduced from Python 2.6 onwards. Shifted the structure checks into their own module. This shifts the special check_structure Check object from pipe_control.structure.main into the new checks module. It allows the check to be performed by other modules in the pipe_control.structure package. Added the missing_error keyword argument to the pipe_centre_of_mass() function. This is from the pipe_control.structure.mass module. The new keyword controls what happens with the absence of structural data. The pipe_control.structure.checks.check_structure() function is now being used to either throw a warning and return [0, 0, 0] or to raise a RelaxError. Fix for the new unit tests - Python 2.5 floats do not have a 'real' property. relax 3.3.2 Updated the minfx version in the release checklist document to version 1.0.11. Updated the relax version in the release checklist document to be more modern. Spelling fixes for the CHANGES file. Updates for the release checklist document. This is mainly because the main release notes are now the relax wiki, for example for the current version at http://wiki.nmr-relax.com/Relax_3.3.1. Spelling fixed throughout the CHANGES document. Removed a few triple spaces in the CHANGES document. Added periods to the end of all items in the CHANGES document. Fix for an 'N/A' in the CHANGES document. Converted a number of single spaces between sentences to double spaces in the CHANGES document. More updates for the announcement section of the release checklist document. The HTML version of the manual is now compiled with Unicode character support. It allows Greek symbols, for example, to be represented as text rather than LaTeX generated PNG images. This fixes titles and massively decreases the number of images required by the HTML pages. Removal of many dual LaTeX and latex2html section titles in the manual. As the HTML manual is now compiled with Unicode support, the Greek characters in the titles are now supported. Therefore in the model-free and the values, gradients, and Hessians chapters, the dual LaTeX and latex2html section titles could be collapsed to the standard LaTeX section title. This will result in better formatting of the manual and its links. Added instructions and a build script for creating a useful version of latex2html. This version is essential for building the HTML version of the manual. The build script downloads the Debian latex2html-2008 sources as well as all Debian patches for latex2html. It then applies a number of patches for fixing and improving the relax documentation. The program is then compiled and can be installed as the root user into /usr/local/. Extended the number of words used in the HTML webpage file names. This is to hopefully prevent files from being overwritten by multiple files having the same name. Added the write out of parameters and χ2 values, when creating a dx_map. Task #7860: When dx_map is issued, create a parameter file which maps parameters to χ2 value. Created system test Relax_disp.test_dx_map_clustered_create_par_file, which must show that relax is not able to find the local minimum under clustered conditions. When creating the map, the map contain χ2 values, which are lower than the clustered fitted values. This should not be the case. Running a larger map with larger bounds and more increments, which should show that there exist a minimum in the minimisation space with a lower χ2 value. Bug #22754: The minimise.calculate() does not calculate χ2 value for clustered residues. Task #7860: When dx_map is issued, create a parameter file which maps parameters to χ2 value. Renamed test scripts and files for producing surface χ2 plots. Renamed sample scripts making surface maps. Added scripts to make surface plots of spin independents parameters δω and Ra2. Added example surface χ2 values for plots. Task #7826: Write an python class for the repeated analysis of dispersion data. Added example save state for more surface plotting. Added boolean argument to dx.map user function, to specify the creation of a parameter and associated χ2 values file. For very very special situations, the creation of this file is not desired. Modified that structure of points in dx.map is always a list of numpy arrays with 3 values. When issuing dx.map user function with points, implemented the writing out of parameter file, with associated calculated χ2 values. Improved the feedback in the User_functions.test_structure_add_atom GUI test. It is now clearer what the input and output data is. The devel_scripts/python_multiversion_test_suite.py script now runs relax with the --time flag. This is for quicker identification of failure points. It will also force the sys.stdout buffer to be flushed more often on Python 2.5 so that it does not appear as if the tests have frozen. Added check to system test Relax_disp.test_cpmg_synthetic_dx_map_points for the creation of a matplotlib surface command plot file. Added the write out of a matplotlib command file, to plot surfaces of a dx map. It uses the minimum χ2 value in the map space, to define surface definitions. It creates a X,Y; X,Z; Y,Z map, where the values in the missing dimension has been cut at the minimum χ2 value. For each map, it creates a projected 3d map of the parameters and the χ2 value, and a heat map for the contours. It also scatters the minimum χ2 value, the 4 smallest χ2 values, and maps any points in the point file, to a scatter point. Mapping the points from file to map points, is done by finding the shortest Euclidean distance in the space from the points to any map points. Fix for testing the raise of expected errors in system tests. The system test will not be tested, if Python version is under version 2.7. Bug #22801: Failure of the relax test suite on Python 2.5. Inserted a z_axis limit for the plotting of 2D surfaces in matplotlib. Added better figure control of χ2 values on z-axis for surface plots. Narrowed in dx_map in system test Relax_disp.test_dx_map_clustered_create_par_file. This is to illustrate the failure of relax finding the global minimum. It seems there is a shallow barrier, which relax failed to climb over, in order to find the minimum value. Added the verbosity argument to the pipe_control.minimise.reset_min_stats() function. All of the minimisation code which calls this now send in their verbosity arguments. This allows the text "Resetting the minimisation statistics." to be suppressed. Added the verbosity argument to the pipe_control.value.set() function. This is passed into the pipe_control.minimise.reset_min_stats() function so its printouts can be silenced. The pipe_control.opendx space mapping code now calls the value.set() function with verbosity=0. This is to silence the very repetitive statistics resetting messages when executing the dx.map user function. Added more checks to the determine_rnd() of the dauvergne_protocol model-free auto-analysis. This is to try to catch bizarre situations such as bug #22730, model-free auto-analysis - relax stops and quits at the polate step. The following additional fatal conditions are now checked for: A file with the same name as the base model directory already exists; The base model directory is not readable; The base model directory is not writable. The last two could be caused by file system corruptions. In addition, the presence of the base model directory is checked for using os.path.isdir() rather than catching errors coming out of the os.listdir() function. These changes should make the analysis more robust in the presence of 'strangeness'. Added an additional check to determine_rnd() of the dauvergne_protocol model-free auto-analysis. This is to try to catch bizarre situations such as bug #22730, model-free auto-analysis - relax stops and quits at the polate step. The additional check is that if the base model directory is not executable, a RelaxError is raised. Added printouts to the determine_rnd() function of the dauvergne_protocol model-free auto-analysis. This is for better user feedback in the log files as to what is happening. It may help in debugging bug #22730: Model-free auto-analysis - relax stops and quits at the polate step. Alphabetical ordering of imports in the dauvergne_protocol model-free auto-analysis. Changed the model-free single spin optimisation title printouts. The specific_analyses.model_free.optimisation.spin_print() function has been deleted. It has instead been replaced by a call to lib.text.sectioning.subtitle(). This is to match the grid search setup title printouts and to differentiate these titles from those printed out by minfx being underlined by '~' characters. Added extensive sectioning printouts to the dauvergne_protocol model-free auto-analysis. The lib.text.sectioning functions title() and subtitle() are now used to mark out all parts of the auto-analysis. This will allow for a much better understanding of the log files produced by this auto-analysis. Complete redesign of the following of text in the relax controller window in the GUI. The current design for some reason no longer worked very often, and there would be many situations where the scrolling to follow the text output would stop and could never be recovered. Therefore this feature has been redesigned. In the LogCtrl element of the relax controller, which displays the relax output messages, the at_end class boolean variable has been introduced. It defaults to True. The following events will turn it off: Arrow keys, Home key, End key, Ctrl-Home key, Mouse button clicks, Mouse wheel scrolling, Window thumbtrack scrolling (the side scrollbar), finding text, the pop up menu 'Go to start', and Select all (menu or Ctrl-A). It will only be turned on in two cases: The pop up menu 'Go to end', and if the caret is on the final line (caused by Ctrl-End, Mouse wheel scrolling, Page Down, Down arrow, Window thumbtrack scrolling, etc.). Three new methods have been introduced to handle certain events: capture_mouse() for mouse button clicks, capture_mouse_wheel() for mouse wheel scrolling, and capture_scroll for window thumbtrack scrolling. Improvements for selecting all text in the relax controller window. Selecting text using the pop up menu or [Ctrl-A] now shifted the caret to line 1 before selecting all text. This deactivates the following of the end of text, if active, as the text following feature causes the text selection to be lost. Modified the behaviour of the relax controller window so that pressing escape closes the window. This involves setting the initial focus on the LogCtrl, and catching the ESC key press in the LogCtrl as well as all relax controller read only wx.Field elements and calling the parent controller handle_close() method. Replaced the hardcoded integer keycodes in the relax controller with the wx variables. This is for the LogCtrl.capture_keys() handler method for dealing with key presses. Improvement for all wizards and user functions in the relax GUI. The focus is now set on the currently displayed page of the wizard. This allows the keyboard to be active without requiring a mouse click. Now text can be instantly input into the first text control and the tab key can jump between elements. As the GUI user functions are wizards with a single page, this is a significant usability improvement for the GUI. The ESC character now closes all wizards and user functions in the relax GUI. By using an accelerator table set to the entire wizard window to catch the ESC keyboard event, the ESC key will cause the _handler_escape() method to be called which then calls the windows Close() method to close the window. Changed the logic for how the new analysis wizard in the GUI is destroyed. This relates to bug #22818, the GUI test suite failures in MS Windows - PyAssertionError: C++ assertion "Assert failure". The Destroy() method has been added to the Analysis_wizard class to properly close all elements of the wizard. This is now called from the menu_new() method of the Analysis_controller class, which is the target of the menu item and toolbar button. To allow the test suite to use this, the menu_new() method now accepts the destroy boolean argument. The test suite can set this to False and then access the GUI elements after calling the method (however the Destroy() method must be called by the test suite). Resign of how the new analysis wizard is handled in the GUI tests. This relates to bug #22818, the GUI test suite failures in MS Windows - PyAssertionError: C++ assertion "Assert failure". The GUI test base class method new_analysis_wizard() has been created to simplify the process. When a new analysis is desired, this method should be called. It will return the analysis page GUI element for use in the test. The method standardises the execution of the new analysis wizard and sets up the analysis in the GUI. It also properly destroys the wizard to avoid the memory leaking issues such as bug #22818. All GUI tests have been converted to use new_analysis_wizard(). This allows the GUI tests to pass on MS Windows. However there are still significant sources of memory leaks (the USER Objects count) visible in the Windows Task Manager. Fix for the gui.fonts module to allow it to be used outside of the GUI. Updated all of the scripts in devel_scripts/gui/. These have been non-functional since the merger of the relax bieri_gui branch back in January 2011. The gui.misc.bitmap_setup() function can now be used outside of the GUI. Fix for the GUI test base class new_analysis_wizard() method for relaxation dispersion analyses. Modified the pipe_control.pipes.get_bundle() function to operate when no pipe is supplied. In this case, the pipe bundle that the current data pipe belongs to will be returned. Created the Periodic_table.has_element() method for the lib.periodic_table module. This is used to simply check if a given symbol exists as an atom in the periodic table. Added 4 unit tests to the _lib.test_periodic_table module for the Periodic_table.has_element() method. Modified the internal structural object backend for the structure.read_pdb user function. The MolContainer._det_pdb_element() method for handling PDB files with missing element information has been updated to use the Periodic_table.has_element() method to check if the PDB atom name corresponds to any atoms in the periodic table. This allows for far greater support for HETATOMS and all of the metals. Created the Structure.test_load_spins_multi_mol system test. This is to test yet to be implemented functionality of the structure.load_spins user function. This is the loading of spin information similar, but not necessarily identical molecules all loaded into the same structural model. For this, the from_mols argument will be added. Fixes for the Structure.test_load_spins_multi_mol system test. The call to the structure.load_spins user function has also been modified so that all 3 spins are loaded at the same time. Implemented the multiple molecule merging functionality of the structure.load_spins user function. The argument has been added to the user function frontend and a description added for this new functionality. In the backend, the pipe_control.structure.main.load_spins() function will now call the load_spins_multi_mol() function if from_mols is supplied. This alternative function is required to handle missing atoms and differential atom numbering. Modified the N_state_model.test_populations system test to test the grid search code paths. This performs a grid search of one increment after minimisation, then switches to the 'fixed' N-state model and performs a second grid search of one increment. This now tests currently untested code paths in the grid_search() API method behind the minimise.grid_search user function. The test demonstrates a bug in the N-state model which was not uncovered in the test suite. Created the N_state_model.test_CaM_IQ_tensor_fit system test. This is for catching bug #22849, the failure of the N-state model analysis when optimising only alignment tensors using RDCs and/or PCSs. This new test checks code paths unchecked in the rest of the test suite, and is therefore of high value. Modified the atomic position handling in pipe_control.structure.main.load_spins_multi_mol(). The multiple molecule merging functionality of the structure.load_spins user function now handles missing atomic positions differently. The aim is that the length of the spin container position variable is fixed for all spins to the number of structures, as the N-state model analysis assumes this equal length for all spins. When data is missing, the atomic position for that structure is now set to None. This will require other modifications in relax to support this new design. Modified the interatom.unit_vectors user function backend to handle missing atomic positions. This is to match the structure.load_spins user function change whereby missing atomic positions are now set to the value of None. Fix for the atomic position handling in pipe_control.structure.main.load_spins_multi_mol(). The dimensionality of the position structure returned by the structural object atom_loop() method needed to be reduced. The structure.load_spins user function now stores the number of states in cdp.N. This is to help the specific analyses which handle ensembles of structures. With the introduction of the from_mols argument to the structure.load_spins user function, the number of states is now not equal to the number of structural models, as the states can now come from different structures of the same model. Therefore the user function will now explicitly set cdp.N to the number of states depending on how the spins were loaded. Clean up and speed up of the N_state_model.test_CaM_IQ_tensor_fit system test. All output files are now set to 'devnull' so that the system test no longer creates any files within the relax source directories. And the optimisation settings have been decreased to hugely speed up the system test. Expanded the lib.arg_check.is_float_matrix() function by adding the none_elements argument. This matches a number of the other module functions, and allows for entire rows of the matrix to be None. Lists of lists containing rows of None are now better supported by the lib.xml functions. The object_to_xml() function will now convert the float parts to IEEE-754 byte arrays, and the None parts will be stored as None in the <ieee_754_byte_array> list node. The matching xml_to_object() function has also been modified to read in this new node format. This affects the results.write and state.save user functions (as well as the results.read and state.load user functions). Added spacing after the minimise.grid_search user function setup printouts. This is for better spacing for the next messages from the specific analysis. Speed up of the N_state_model.test_CaM_IQ_tensor_fit system test. This test is however still far too slow. Added printouts to pipe_control.pcs.return_pcs_data() and pipe_control.rdc.return_rdc_data(). These functions now accept the verbosity argument which if greater than 0 will activate printouts of how many RDCs or PCSs have been assembled for each alignment. This will be useful for user feedback as the spin verses interatomic data container selections can be difficult to understand. The verbosity argument for the N-state model optimisation is now propagated for more printouts. The argument for the calculate() and minimise() API methods is now sent into specific_analyses.n_state_model.optimisation.target_fn_setup(), and from there into the pipe_control.pcs.return_pcs_data() and pipe_control.rdc.return_rdc_data() functions. That way the number of RDCs and PCSs used in the N-state model is reported back to the user for better feedback. Updated the N_state_model.test_CaM_IQ_tensor_fit system test so it operates correctly as a GUI test. All user functions are now executed through the special self._execute_uf() method to allow either the prompt interpreter or the GUI to execute the user function. Modified the N_state_model.test_CaM_IQ_tensor_fit system/GUI test for implementing a new feature. The 'spin_selection' argument has been added to the interatom.define user function. This will be used to carry the spin selections over into the interatomic data containers. Implemented the spin_selection Boolean argument for the interatom.define user function. This has been added to the frontend with a description, and to the backend. When set, it allows the spin selections to define the interatomic data container selection. Changed the spin_selection argument default in the interatom.define user function backend. This now defaults to False to allow other parts of relax which call this function to operate as previously. The default for the interatom.define user function is however still True. Modified the Structure.test_load_spins_multi_mol system test for the spin.pos variable changes. The atomic position for an ensemble of structures is now set to None rather than being missing, so the system test has been updated to check for this. The align_tensor.display user function now has more consistent section formatting. The section() and subsection() functions of the lib.text.sectioning module are now being used to standardise these custom printouts with the rest of relax. Modifications to the new N_state_model.test_CaM_IQ_tensor_fit system test. The system test now checks all of the optimised values to make sure the correct values have been found. That will block any future regressions in this N-state model code path. The system test is now also faster. And the pcs.structural_noise user function RMSD value has been set to 0.0 so that the test no longer has a random component affecting the final optimised values. Added printouts for the rdc.calc_q_factors and pcs.calc_q_factors user functions. These are activated by the new verbosity user function argument which defaults to 1. If the value is greater than 0, then the backend will print out all the calculated Q factors. The verbosity argument of the RDC and PCS q_factors() functions now defaults to 1. This causes the Q factors to be printed out at the end of all N-state model optimisations. Created the Structure.test_bug_22860_CoM_after_deletion system test. This is to catch bug #22860, the failure of the structure.com user function after calling structure.delete. Fix for the checks in the new Structure.test_load_spins_multi_mol system test. A spin index was incorrect. Fix for the structure.load_spins user function when the from_mols argument is used. The load_spins_multi_mol() function of the pipe_control.structure.main module was incorrectly handling the atomic position returned by the internal structural object atom_loop() method. This position is a list of lists when multiple models are present. But when only a single model is present, it returns a simple list. Modified the Structure.test_bug_22860_CoM_after_deletion system test to expect a RelaxNoPdbError. This tests that the structure.com user function raises RelaxNoPdbError after deleting all of the structural information from the current data pipe. The mol_name argument is now exposed in the structure.add_atom user function. This has been added as the first argument of the user function to allow new molecules to be created or to allow the atom to be placed into a specific molecule container. The functionality was already implemented in the backend, so it has been exposed by simply adding a new argument definition to the user function. Created the Structure.test_bug_22861_PDB_writing_chainID_fail system test. This is to catch bug #22861, the chain IDs in the structure.write_pdb user function PDB files are incorrect after calling structure.delete. Small modification of the Structure.test_bug_22861_PDB_writing_chainID_fail system test. File metadata is now being set to demonstrate that the structure.delete user function does not remove this once there is no more data left for the molecule. Small indexing fixes for the dispersion chapter of the relax manual. Fix for system test Relax_disp.test_cpmg_synthetic_dx_map_points. Another import line was written to the matplotlib script. Speedup and fix for system test Relax_disp.test_dx_map_clustered_create_par_file. The following test was taken out, since this a particular interesting case. There exist a double minimum, where relax has not found the global minimum. This is due to not grid searching for Ra2, but using the minimum value. Removed debugging code from the N_state_model.test_CaM_IQ_tensor_fit system test. This was an accidentally introduced state.save user function used to catch the system test state. It would results in the 'x.bz2' file being dumped in the current directory. Loosened the checks in the Relax_disp.test_baldwin_synthetic_full system test. This is to allow the test to pass on Python 2.5 and 3.1 on a 32-bit GNU/Linux system. Fix for the Relax_disp.test_cpmg_synthetic_dx_map_points system test for certain systems. This change is to allow the test to pass on Python 2.5 and 3.1 on a 32-bit GNU/Linux system. This may be related to 32-bit numpy 1.6.2 verses later numpy versions causing precision differences. Fixes for the Relax_disp.test_hansen_cpmg_data_missing_auto_analysis system test for certain systems. The optimisation precision has been increased, and the value checking precision has been decreased. This change is to allow the test to pass on Python 2.5 and 3.1 on a 32-bit GNU/Linux system. This may be related to 32-bit numpy 1.6.2 verses later numpy versions causing precision differences. Converted all the extern.numdifftools modules using the dos2unix program. Updated the Python 2 to Python 3 migration document to be more current. Small edit of the docs/devel/2to3_checklist document. Expanded the Python 2 to 3 conversion document to list the 2to3 command individually. The ImportErrors in unit tests are now correctly handled by the relax test suite. If an ImportError occurred, this was previously killing the entire test suite. The target_function.relax_fit module unit tests are now skipped if the C module is not compiled. Expanded the Python 2 to 3 conversion document. Small update to the 2to3_checklist document - the print statement conversion has been added. The lib.errors module is now importing lib.compat.pickle for better Python 2 and 3 support. This shifts the compatibility code from lib.errors into lib.compat so that the 2to3 program will not touch the lib.errors module. Better Python 3 compatibility in some test suite shared data profiling scripts. These changes invert the logic, importing the Python 3 builtins module and aliasing xrange() to range(), and passing if an ImporError occurs. The code will now no longer be modified by the 2to3 program. Unicode fixes for the "\u" string in "\usepackage" in the module docstring. This requires escaping as "\\usepackage" to avoid the unicode character '\u'. The lib.check_types module now imports io.IOBase from the lib.compat module. This is to shift more Python 2 vs. 3 compatibility into lib.compat and out of all other modules. Python 3 improvements - changed how the Python 3 absent builtins.unicode() function is handled. The aliased builtins.str() function is now referenced as lib.compat.unicode(). The Python 2 __builtin__.unicode() function is also aliased to lib.compat.unicode(). The GUI using this function now import it from lib.compat. Removed the writable base directory check in the dauvergne_protocol auto-analysis. This check was causing the system test to fail if the user does not have write access to the installed relax directory. Expanded the Mac_framework_build_3way document to include matplotlib. Important bug fix for racing causing the GUI to freeze. This is really only seen in the GUI tests on MS Windows systems, as a user could never be fast enough with the mouse. The GUI interpreter flush() method for ensuring that all user functions in the queue have been cleared now calls wx.Yield() to force all wxPython events to also be flushed. This change will avoid random freezing of the relax test suite. Bug fix for the Mf.test_bug_21615_incomplete_setup_failure GUI test on MS Windows systems. The GUI interpreter flush() method needs to be called between the two structure.load_spins user function calls. Without this, the test will freeze on MS Windows. The freezing behaviour is however not 100% reproducible and is dependent on the Windows version and wxPython version. Shifted a number of wx.NewId() calls to the module namespace to conserve IDs. These are for the menus in the main window and in the spin view window. Shifted the wx.NewId() calls for the spectrum list GUI element to the module namespace. These IDs are used for the pop up menus. The change avoids repetitive calls to wx.NewId() every time a right click occurs, conserving wx IDs so that they are not exhausted when running the test suite or running the GUI for a long time. More shifting of wx.NewId() calls for popup menus to module namespaces to conserve IDs. Converted all of the GUI wizard button IDs to -1, as they are currently unused. This should conserve wx IDs, especially in the test suite. Shifted the main GUI window toolbar button wx IDs to the module namespace. This has no effect apart from better organising the code. Shifted the relax controller window popup menu wx IDs to the module namespace. This is simply to better organise the code to match the other GUI module changes. Menus created by the gui.components.menu.build_menu_item() now default to the wx ID of -1. This is to conserve wx IDs. If the calling code does not provide the ID, there is no need to grab one from the small pool of IDs. Shifted the spin viewer GUI window toolbar button wx IDs to the module namespace. This should conserve wx IDs as the window is created and destroyed, as only 2 IDs will be taken from the small pool for the entire lifetime of the program. Shifted all of the wx.NewId() calls for the new analysis wizard into the module namespace. This will hugely save the number of wx IDs used by the GUI, especially in the test suite. Instead of grabbing 8 IDs from the small pool every time the new analysis wizard is created, only 8 IDs for the lifetime of the program will be used. Another large wx ID saving change. The ID associated with the special accelerator table that allows the ESC button to close relax wizards is now initialised once in the module namespace, and not each time a wizard is created. A small wx ID conserving change - the 'Execute' button in the analysis tabs now uses the ID of -1. A unique ID is not necessary and is unused. The user function class menus no longer have unique wx IDs, as these are unnecessary. This conserves the small pool of unique wx IDs, as the spin viewer window is created and destroyed. Bug fix for the structure.load_spins user function new from_mols argument. This was incorrectly using the pipe_control.pipes.pipe_names() function to obtain its default values in the GUI (although this is not currently uesd). The result was a non-fatal error message on Mac OS X systems of "Python[1065:1d03] *** __NSAutoreleaseNoPool(): Object 0x3a3944c of class NSCFString autoreleased with no pool in place - just leaking". Added a debugging Python version check to the devel_scripts/memory_leak_test_relax_fit.py script. This prevents the script from being executed with a normal Python binary. Created the blacklisted Noe.test_noe_analysis_memory_leaks GUI test. This long test can be manually run to help chase down memory leaks. This can be monitored using the MS Windows task manager, once the 'USER Objects' column is shown. If the USER Objects count reaches 10,000 in Windows, then no more GUI elements can be created and the user will see errors. Added a printout to the Noe.test_noe_analysis_memory_leaks GUI test to help with debugging. Improved debugging printouts for the Noe.test_noe_analysis_memory_leaks GUI test. Small fix for the GUI analysis deletion method to prevent racing in the GUI tests. Redesigned how wizards are destroyed in the GUI. The relax wizard Destroy() method is now overridden. This allows the buttons in the wizard to be properly destroyed, as well as all wizard pages. This should remove a lot of GUI memory leaks. Created the General.test_new_analysis_wizard_memory_leak blacklisted GUI test. This will be used to check for memory leaks in the new analysis wizard. Removed an unused dictionary from the GUI wizard object. Added a wx.Yield() before destroying the new analysis wizard via menu_new(). This is to avoid racing which can be triggered in the test suite. = ..→

Random screenshots relax starting interface The analysis selection wizard Steady-state NOE analysis R1 analysis R2 analysis Model-free analysis The relax controller Spin viewer window Results viewer window Pipe editor window relax prompt window About GUI screen About relax screen