# relax release changes

From relax wiki

This is a collection of all of the changes lists for each released relax version.

## Contents

- 1 Version 4 of relax
- 2 Version 3 of relax
- 3 Version 2 of relax
- 4 Version 1 of relax
- 4.1 relax 1.3 series
- 4.1.1 relax 1.3.16
- 4.1.2 relax 1.3.15
- 4.1.3 relax 1.3.14
- 4.1.4 relax 1.3.13
- 4.1.5 relax 1.3.12
- 4.1.6 relax 1.3.11
- 4.1.7 relax 1.3.10
- 4.1.8 relax 1.3.9
- 4.1.9 relax 1.3.8
- 4.1.10 relax 1.3.7
- 4.1.11 relax 1.3.6
- 4.1.12 relax 1.3.5
- 4.1.13 relax 1.3.4
- 4.1.14 relax 1.3.3
- 4.1.15 relax 1.3.2
- 4.1.16 relax 1.3.1
- 4.1.17 relax 1.3.0

- 4.2 relax 1.2 series

- 4.1 relax 1.3 series
- 5 References
- 6 See also

# 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 I_{0}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 2
^{nd}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 R
_{2,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 R
_{2,eff}values. This shows that the replicated R_{2,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 R
_{2,eff}values is not handled well. - In the function of r2eff_read in data module of the dispersion, added the possibilities to read R
_{2,eff}values which are replicated. This is done first checking if the dispersion key exists in the R_{2,eff}dictionary. If it exists, continue add 0.001 to the frequency until a new possibility exists. This should help handle multiple R_{2,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 R
_{2,eff}points with the same frequency. If the spin-container already contain R_{2,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
*S*attribute, as reported by Martin Ballaschk.^{2} - 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
*S*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.^{2}

### 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 > 1e
^{6}. 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 N
^{M}, 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 (4500
^{2}) rather than a quarter of a million (500^{2}). 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 2
^{nd}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 2
^{nd}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 2
^{nd}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 Ca
^{2+}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 2
^{nd}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 2
^{nd}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 2
^{nd}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 2
^{nd}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 2
^{nd}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 2
^{nd}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 2
^{nd}rotor model of the CaM frame order test data. The tilt angle was not set, and therefore the old data matched the non-tilted 1^{st}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 2
^{nd}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 2
^{nd}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 2
^{nd}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 2
^{nd}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 2
^{nd}pivot point infrastructure from the frame order analysis. The 2^{nd}pivot is now defined via the pivot_disp parameter. - Added the 2
^{nd}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 1
^{st}technique, which is currently used in the frame order analysis, and the 7^{th}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 Ln
^{3+}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 1
^{st}pivot to atom vector rotated by the 1^{st}mode of motion; the 2^{nd}pivot to 1^{st}pivot vector rotated by the 2^{nd}mode of motion (together with the rotated 1^{st}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 Ln^{3+}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 2
^{nd}pivot is optimised and the inter-pivot distance along the z-axis gives the position of the 1^{st}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 2
^{nd}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 2
^{nd}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 1
^{st}or 2^{nd}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 1
^{st}mode of motion is about the 2^{nd}pivot, and the 2^{nd}mode of motion about the 1^{st}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 Ca
^{2+}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 Ca
^{2+}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 5
^{th}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 2
^{nd}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 2
^{nd}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 2
^{nd}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 2
^{nd}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 2
^{nd}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 * 10
^{M}, 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 1
^{st}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 2
^{nd}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 1
^{st}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 1
^{st}and 2^{nd}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 1
^{st}and 2^{nd}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 1
^{st}degree in-frame frame order matrix for the rotor model. - Created the Grace graphs for the rotor model 1
^{st}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 1
^{st}degree in-frame frame order matrix for the free rotor model. - Created the Grace graphs for the free rotor model 1
^{st}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 1
^{st}degree in-frame frame order matrix for the isotropic cone model. - Created the Grace graphs for the isotropic cone model 1
^{st}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 1
^{st}degree in-frame frame order matrix for the torsionless isotropic cone model. - Created the Grace graphs for the torsionless isotropic cone 1
^{st}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 1
^{st}degree in-frame frame order matrix for the free rotor isotropic cone model. - Created the Grace graphs for the free rotor isotropic cone 1
^{st}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 1
^{st}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 1
^{st}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 1
^{st}degree in-frame frame order matrix for the torsionless pseudo-ellipse model. - Created the Grace graphs for the torsionless pseudo-ellipse model 1
^{st}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 2
^{nd}degree frame order matrix equations. - More simplifications of the pseudo-ellipse 2
^{nd}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 2
^{nd}degree frame order matrix compilation. - Removal of many repetitive calculations in the pseudo-ellipse 2
^{nd}degree frame order matrix equations. - Simplifications of pseudo-ellipse 1
^{st}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 2
^{nd}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 1
^{st}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 1
^{st}degree in-frame frame order matrix for the free_rotor pseudo-ellipse model. - Speedups and simplifications of the free rotor pseudo-ellipse 2
^{nd}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 1
^{st}degree frame order matrix for the double_rotor model. - Created the Grace graphs for the double rotor model 1
^{st}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 1
^{st}degree frame order matrix ᛞ_{22}element. - Updated all of the pseudo-ellipse 1
^{st}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 1
^{st}degree frame order matrix. The 11 element was of the wrong sign. - Fixes for the torsionless pseudo-ellipse 1
^{st}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 1
^{st}degree frame order matrix graphs calculated using relax. The 1^{st}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 1
^{st}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 1
^{st}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 2
^{nd}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 2
^{nd}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 (2D
_{a}^{2}(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 D
_{x}≤ D_{y}≤ D_{z}. - More fixes for the Structure.test_create_diff_tensor_pdb_oblate system test. The initial D
_{iso}value is now set to the real final D_{iso}, and the PDB file contents have been updated for the fixed oblate spheroidal diffusion relaxation data. - Updates for many of the Diffusion_tensor system tests. This is due to the changed directory names in test_suite/shared_data/diffusion_tensor/. The ds.diff_dir variable has been introduced to point to the correct data directory.
- Large improvement for the GUI test tearDown() clean up method, fixing the tests on wxPython 2.8. The user function window destruction has been shifted into a new clean_up_windows() method which is executed via wx.CallAfter() to avoid racing conditions. In addition, the spin viewer window is destroyed between tests. The spin viewer window change allows the GUI tests to pass on wxPython 2.8 again. This also allows the GUI tests to progress much further on Mac OS X systems before they crash again for some other reason. This could simply be hiding a problem in the spin viewer window. However it is likely to be a racing problem only triggered by the super fast speed of the GUI tests and a normal user would never be able to operate the GUI on the millisecond timescale and hence may never see it.
- Reverted the wxPython 2.8 warning printout when starting relax, introduced in relax 3.3.5.
- Reverted the skipping of the GUI tests on wxPython 2.8, introduced in relax 3.3.5.
- Reverted the General.test_bug_23187_residue_delete_gui GUI test disabling, introduced in relax 3.3.5. The 'Bus Error' on Mac OS X due to this test is no longer an issue, as the spin viewer window is now destroyed after each GUI test.
- Created a special Destroy() method for the spin viewer window. This is for greater control of the spin viewer window destruction. First the methods registered with the observer objects are unregistered, then the children of the spin viewer window are destroyed, and finally the main spin viewer window is destroyed. This change saves a lot of GUI resources in the GUI tests (there is a large reduction in 'User Objects' and 'GDI Objects' used on MS Windows systems, hence an equivalent resource reduction on other operating systems).
- Fix for the GUI test clean_up_windows() method called from tearDown(). The user function window (Wiz_window) must be closed before the user function page (Uf_page), so that the Wiz_window._handler_close() can still operate the methods of the Uf_page. This avoids a huge quantity of these errors: Traceback (most recent call last): __getattr__ wx._core.PyDeadObjectError: The C++ part of the Uf_page object has been deleted, attribute access no longer allowed.
- Simplification of the Dead_uf_pages.test_mol_create GUI test. The RelaxError cannot be caught from the GUI user function window, therefore the try statement has been eliminated.
- More memory saving improvements for the GUI test suite tearDown() method. The clean_up_windows() method now loops through all top level windows (frames, dialogs, panels, etc.) and calls their Destroy() method.
- Created the gui.uf_objects.Uf_object.Destroy() method. This will be used to cleanly destroy the user function object.
- Modified the GUI test suite _execute_uf() method. This user function execution method now calls the user function GUI object Destroy() method to clean up all GUI objects. This should save memory for GUI objects in the GUI test suite.
- Modified the GUI test suite tearDown() method. The clean_up_windows() method called by tearDown() now prints out a lost of all of the living windows instead of trying to destroy them (which causes the running of the GUI tests in the GUI to cause the GUI to be destroyed). The printouts will be used for debugging purposes.
- Fixes for the custom Wiz_window.Destroy() method. This will now first close the wizard window via the Close() method to make sure all of the wizard pages are properly updated. In the end the wizard DestroyChildren() method is called to clean up all child wx objects, and finally Destroy() is called to eliminate the wizard GUI object.
- The GUI test suite tearDown() method now calls the user function GUI wizard Destroy() method. This is for better handling of user function elimination.
- Fixes for the user function GUI object Destroy() method. This matches the code just deleted in the GUI test suite tearDown() method for handing the user function page object.
- More fixes for the user function GUI object Destroy() method. This page GUI object is destroyed by the wizard window Destroy() method, so destroying again causes wxPython runtime errors.
- Spacing printout for the list of still open GUI window elements. This is for the GUI test tearDown() method.
- Shifted the printouts from the GUI tests suite clean_up_windows() method to the tearDown() method. This change means that the printouts are not within a wx.CallAfter() call, but rather at the end of the tearDown() method just prior to starting the next test.
- Simplification of the GUI analysis post_reset() method. This now uses the delete_all() and hence delete_analysis() methods to clean up the GUI. The reset argument has been added to skip the manipulation of relax data store data, as the data store is empty after a reset. However the calling of the delete_analysis() method now ensures that the analysis specific delete() method is now called so that the GUI elements can be properly destroyed.
- Proper destruction of the peak analysis wizard of the NOE GUI analysis. The peak wizard's Destroy() method is now called and the self.peak_wizard object deleted in the NOE GUI analysis delete() method.
- Improved memory management in the NOE GUI analysis peak_wizard_launch() method. This method was just overwriting the self.peak_wizard object with a new object. However this does not destroy the wxPython window. Now if a peak wizard is detected, its Destroy() method is called before overwriting the object.
- Improved GUI clean up when terminating GUI tests. The clean_up_windows() method, called from tearDown(), now also destroys the pipe editor window, the results viewer window, and the prompt window. This ensures that all of the major relax windows are destroyed between GUI tests.
- Improved memory management in the relaxation curve-fitting GUI analysis. The peak intensity loading wizard is now properly destroyed. This is both via the delete() function for terminating the analysis calling the wizard Delete() method, and in the peak_wizard_launch() method calling the wizard Delete() method prior to overwriting the self.peak_wizard object with a new GUI wizard.
- Improved memory management in the model-free GUI analysis. The dipole-dipole interaction wizard is now properly destroyed. This is both via the delete() function for terminating the analysis calling the wizard Delete() method, and in the setup_dipole_pair() method calling the wizard Delete() method prior to overwriting the self.dipole_wizard object with a new GUI wizard.
- Improved memory management in the model-free GUI analysis. The analysis mode selection window (a wx.Dialog) is now being destroyed in the analysis delete() method. This appears to work on Linux, Windows, and Mac systems.
- Improved memory management in the model-free GUI analysis. The local tm and model-free model windows are now destroyed in the GUI analysis delete() method.
- Improved termination of the GUI tests. The clean_up_windows() method now calls the results viewer and pipe editor window handler_close() methods. This ensures that all observer objects are cleared out so that the methods of the dead windows can no longer be called.
- Fix for the previous commit, calls to wx.Yield() are required to flush the calls on the observer objects after unregisteristing them and deleting the results and pipe editor windows.
- Improved memory management in the relaxation dispersion GUI analysis. The peak intensity loading wizard is now properly destroyed. This is both via the delete() function for terminating the analysis calling the wizard Delete() method, and in the peak_wizard_launch() method calling the wizard Delete() method prior to overwriting the self.peak_wizard object with a new GUI wizard.
- Created custom Destroy() methods for the pipe editor and results viewer GUI windows.
- Improved memory management in the relaxation dispersion GUI analysis. The dispersion model list window is now destroyed in the GUI analysis delete() method.
- Fixes for the custom Destroy() methods for the pipe editor and results viewer GUI windows. The event argument is now a keyword argument which defaults to None. This allows the Destroy() methods to be called without arguments.
- Temporary disablement of the results viewer window destruction in the GUI tests. This currently, for some unknown reason, causes segfault crashes of the GUI tests on Linux systems.
- Changes for how the main GUI windows are destroyed by the GUI test tearDown() method. These changes revert some of the code of previous commits. The recently introduced pipe editor and results viewer windows Delete() methods have been deleted. Instead the Close() methods are called in the tearDown() method to unregister the windows from the observer objects, followed by a wx.Yield() call to flush the wx events, and then the clean_up_windows() GUI test base method is called within a wx.CallAfter() call. This avoids the racing induced segfaults in the GUI tests.
- Improved memory management in the spin viewer window. The spin loading wizard is now destroyed in the Destroy() method as well as before reinitialising the wizard in the load_spins_wizard() method.
- The GUI tests tearDown() method now prints out the Wizard windows title, if not destroyed.
- The Wizard window title is now being stored as a class instance variable.
- Improved memory management in the relaxation data list GUI element, as well as the base list object. The relaxation data loading wizard is now destroyed in the Base_list.delete() method, or any wizard for that matter. In addition, the relaxation data loading wizard is destroyed before reinitialising the wizard in the wizard_exec() method.
- Better memory management for the missing data dialog in the GUI analyses. The dialog is now stored as the class variable missing_data, and then is destroyed in the analysis delete() method. Without this, the wxPython dialog would remain in memory for the lifetime of the program.
- Improved memory management for the Sequence and Sequence_2D input GUI elements. These are mainly used in the user function GUI windows. The dialogs are now destroyed before a second is opened.
- Improved memory management for the GUI user function windows. The Destroy() method will now destroy any Sequence or Sequence_2D windows used for the user function arguments.
- The relax prompt window is now being destroyed by the GUI test suite tearDown() method. The window is first closed in the tearDown() method and then destroyed in the clean_up_windows() method.
- Added memory management checking to the GUI test suite tearDown() method. If any top level windows are present, excluding the main GUI window and the relax controller, then a RelaxError will be raised. Such a check will significantly help in future GUI coding, as now there will be feedback if not all windows are properly destroyed.
- Popup menus are now properly destroyed in the GUI tests. In many instances, the wx.Menu.Destroy() method was only being called when the GUI is shown. This causes memory leaking in the GUI tests.
- Changed the title for the user function GUI windows. To better help identify what the window is, the title is now the user function name together with text saying that it is a user function.
- Removed the wx.CallAfter() call in the GUI tests tearDown() method. This was used to call the clean_up_windows() method. However the value of wx.Thread_IsMain() shows that the tearDown() method executes in the main GUI thread. Therefore the wx.CallAfter() call for avoiding racing conditions is not needed.
- Fix for the GUI tests clean_up_windows() tearDown method. After destroying all of the main GUI windows, a wx.Yield() call is made to flush the wxPython event queue. This seems to help with the memory management.
- Temporary disabling of the memory management check in the GUI tests tearDown() method. For some reason, it appears as if it is not possible to destroy wx Windows on MS Windows.
- Created the relax GUI prompt Destroy() method. This is used to cleanly destroy the GUI prompt by first unregistering with the observer objects, destroying then deleting the wx.py.shell.Shell instance, and finally destroying the window.
- Modified the manual_c_module.py developer script so that the path can be supplied on the command line.
- Removed some unused imports, as found by devel_scripts/find_unused_imports.py.
- Added a copyright notice to the memory_leak_test_relax_fit.py development script. This is to know how old the script is, to see how out of date it is in the future.
- Created the memory_leak_test_GUI_uf.py development script. This is to help in tracking down memory leaks in the relax GUI user functions. Instead of using a debugging Python version and guppy (wxPython doesn't seem to work with these), the pympler Python package and its muppy module is used to produce a memory usage printout.
- Clean up of the memory_leak_test_GUI_uf.py development script.
- Created the new devel_scripts/memory_management/ directory. This will be used for holding all of the memory C module leak detection, GUI object leak detection, memory management, etc. development scripts.
- Shifted the memory_leak_test_GUI_uf.py script to devel_scripts/memory_management/GUI_uf_minimise_execute.py.
- Created a base class for the memory management scripts for the GUI user functions. The core of the GUI_uf_minimise_execute.py script has been converted into the GUI_base.py base class module. This will allow for new GUI user function testing scripts to be created.
- Removal of unused imports from the GUI user function memory testing scripts.
- Created a script for testing the memory management when calling the time GUI user function.
- Large memory management improvement for the relax GUI wizards and GUI user functions. The pympler.muppy based memory management scripts in devel_scripts/memory_management for testing the GUI user function windows was showing that for each GUI user function call, 28 wx._core.BoxSizer elements were remaining in memory. This was traced back to the gui.wizards.wiz_objects.Wiz_window class, specifically the self._page_sizers and self._button_sizers lists storing wx.BoxSizer instances. The problem was that 16 page sizers and 16 button sizers were initialised each time for later use, however the add_page() method only added a small subset of these to the self._main_sizer wx.BoxSizer object. But the Destroy() method was only capable of destroying the wx.BoxSizer instances associated with another wxPython object. The fix was to add all page and button sizers to the self._main_sizer object upon initialisation. This will solve many memory issues in the GUI, especially in the GUI tests on Mac OS X systems causing 'memory error' or 'bus error' messages and on MS Windows due to 'USER Object' and 'GDI object' limitations.
- The maximum number of pages in the GUI wizard is no longer hardcoded. The max_pages argument has been added to allow this value to be changed.
- Fix for GUI wizards and GUI user functions. The recent memory management changes caused the wizard windows to have an incorrect layout so that the wizard pages were not visible. Reperforming a layout of the GUI elements did not help. The solution is to not initialise sets of max_pages of wx.BoxSizer elements in the wizard __init__() method, but to generate and append these dynamically via the add_page() method. The change now means that there are no longer multiple unused wx.BoxSizer instances generated for each wizard window created.
- Fix for the GUI wizard _go_next() method. The way to determine if there are no more pages needs to be changed, as there are now no empty list elements at the end of the wizard storage objects.
- Another fix for the now variable sized wizard page list. This time the fix is in the GUI user function __call__() method.
- Created the Relax_fit.test_bug_23244_Iinf_graph system test. This is to catch bug #23244.

### 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 R
_{1}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 k
_{AB}. 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 k
_{ex}. But the value only differ from k_{ex}=1826 to k_{ex}=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 [5]. 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 I
_{0}(1 - e^{−R1.t}) where I_{0}= 1000000000000000.00 and R_{1}= 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 R
_{1}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 [6]. 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 R
_{1}script. This change follows the discussion in the message [7]. - Created the Relax_fit.test_saturation_recovery system test. This follows from the discussion of [8].
- 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 [R
_{x}, 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 I_{0}. - 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 I_{0}. - 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 R
_{1}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
_{∞}- I_{0}e^{-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 R_{x}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 R
_{1}and R_{2}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 [9]. 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 R
_{1}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 [10].
- 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 [11].
- 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
^{15}N 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 {S
_{xx}, S_{xy}, S_{xz}, S_{yx}, S_{yy}, S_{yz}, S_{zx}, S_{zy}, S_{zz}} 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}, A_{0}, A_{1}, A_{2}} 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}, A_{0}, A_{1}, A_{2}} 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}, A_{0}, A_{1}, A_{2}} 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 <v
_{1}|v_{2}>. - 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}, S_{0}, S_{1}, S_{2}}. 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}, A_{0}, A_{1}, A_{2}}. 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 S
_{m}element have been converted to A_{m}. - 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 R
_{a}^{2}. - 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 R
_{a}^{2}, 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.

### relax 3.3.1

- Epydoc docstring fix for the dep_check.version_comparison() function.
- Removed ZZ and HD exchange from the dispersion chapter of the relax manual. These would probably require completely new analysis types added to relax to analyse such data.
- Updated the 'Announcement' section of the release checklist document. This now includes details about initially composing the message using the relax wiki, and then how that text and the CHANGES file are used for the email announcement and the Gna! news item.
- Small changes for the Gna! news item in the release checklist document.
- Modified the announcement section of the release checklist document. Text about removing wiki markup has been added.
- More expansion of the release checklist document. Added text about creating internal and external links for the wiki release notes.
- Modified system test Relax_disp.test_show_apod_extract that test output from showApod. The output can be different according to NMRPipe version. The 'Noise Std Dev' is though the same.
- Fix for comments to dependency check of showApod.
- Fix for raising error when calling showApod, and subprocess module not available.
- Fix for the dependency check for showApod in system tests.
- Further extended the protocol for repeated dispersion analysis. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Extended the system test for the protocol for repeated dispersion analysis. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Added a relaxation dispersion model profiling log file for relax version 3.3.0 vs. 3.2.3. This is the output from the dispersion model profiling master script. These numbers will be used for the relax 3.3.0 release notes.
- Fixes for the relax 3.3.0 vs. 3.2.3 dispersion model profiling log file. The numeric model numbers were incorrectly scaled and a factor of 10 too high.
- Fixes for the scaling factors in the dispersion model super profiling script.
- Editing of the relax 3.3.0 features section of the CHANGES file. This will be used for the release notes.
- Added more test data for the repeated analysis. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Updated the Baldwin 2014 reference in the relax manual. The pybliographic software was used to format this BibTeX entry. This was updated as volume and page number information is now available.
- Updated the Morin et al, 2014 paper (the relax relaxation dispersion paper) reference in the manual. The paper now has volume and page information.
- Added some more user function ranamings to the translation table. These were identified while preparing the release notes on the wiki (http://wiki.nmr-relax.com/Category:Release_Notes, http://wiki.nmr-relax.com/Release_notes).
- Stored a frequency dependent dictionary with spectrum IDs and repeated PMG frequencies in setup pipe. This information will progress out through children pipes. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Further extended methods in the class for repeated analysis of dispersion data. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Updated the release checklist document, including adding a section about cross-linking. The cross-linking is important for search engine indexing.
- Created a simple script for printing out the names of all user functions.
- Added listings of all user functions from relax version 2.0.0 all the way to relax 3.3.0. This will be used to look at how the user function names have changed with time.
- Added a script and log file for comparing relax user function differences between versions.
- Created a document for relax users which follows the changes to the user function names.
- For the spin.display user function, added the print out of spin ID and status for selection. This is to help with showing the spin ID string for selection, and the current status of selection. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- To the back-end of display pipes, added functionality to sort the pipe names before printing. Also added the return of the list of pipes, with its associated information about pipe type, and pipe_bundle. This is to help with getting a better overview for multiple pipes in data store. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Parsed the force flag from front end of value.set to back end. Bug #22598. Back end of value.set does not respect force=False flag.
- Broke optimisation function into smaller functions. This is to help selecting spins, do particular grid search and minimise. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Modified system test to follow the new functions in the auto analysis. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Shifted the user function listing script into the test suite directory where the results are.
- Created a script for printing out relax 1.3 user functions.
- Stripped out all of the relax intro and script printouts from the user function listing files. This allows the diff.py script to be simplified.
- Updated the relax 1.3 user function printout script and added many printouts. The printouts are for relax versions 1.3.5 to 1.3.16. The earlier relax versions used the relax 1.2 user function setup.
- Created a script for printing out all user functions for relax 1.2 versions. This also includes the relax 1.3.0 to relax 1.3.4 versions.
- Added the relax 1.3.0 to relax 1.3.4 user function printouts.
- Changed the behaviour of the script for showing user function difference between relax versions. The relax versions are now reversed so the oldest version is at the bottom of the difference printout.
- Added the relax 1.0.1 to relax 1.2.15 user function printouts. The diff.log file has also been updated with all of these versions.
- Updated the user_function_changes.txt document. This now lists all changes in the user function naming from relax version 1.0.1 all the way to relax 3.3.0.
- Added all remaining user function ranamings since relax 2.0.0 to the translation table. These were taken directly from the docs/user_function_changes.txt document.
- Added all user function ranamings since relax 1.3.1 to the translation table. These were taken directly from the docs/user_function_changes.txt document. Earlier relax versions are far too different, so this will be the earliest relax version for this translation table. The relax 1.2 and earlier (and 1.3.0) versions used the run argument throughout and the scripting was so different, that telling the user how to upgrade to new user functions is pointless. And the release date of relax 1.2.15, the last of these old designs was in November 2008.
- Changed the order of the two relax versions being compared for user function changes. This is in the diff.py script and log file and the user_function_changes.txt document.
- Changed the organisation of the files in the docs/ directory. A new docs/devel directory has been created and the 2to3_checklist, Mac_framework_build_3way, package_layout, and prompt_screenshot.txt documents shifted into it. This is to hide or abstract away the development documents so that relax users do not see them when looking into docs/. This should make the directory less intimidating.
- Shifted the Release_Checklist document into docs/devel/ to hide it from users.
- Correction for the noe.read to spectrum.read_intensities user function change. This is for the translation table used to catch old user function calls.
- Initial try to implement plotting in the repeated auto analysis protocol. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Small improvement of the matplotlib plotting of data in the repeated analysis protocol. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Fix for calling correct folder with test intensities. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- For the class of repeated analysis, implemented method to collect peak intensity, and function to plot the correlation. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Added system test Relax_disp.test_repeat_cpmg to be skipped, if no matplotlib module exists. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Added the Gimp XCF file for the logo of the relax wiki.
- Added system test Relax_fit.test_curve_fitting_height_estimate_error() for the manual and automated analysis of exponential fit. This is to prepare for new methods in the auto analysis protocol.
- In the auto analysis of exponential fitting, changed the minimisation method from simplex to Newton, to speed-up the fitting. This is for master Monte Carlo simulations.
- In the system test Relax_fit.test_curve_fitting_height_estimate_error(), moved the auto-detection of replicated spectra into the manual method. This is to prepare for auto-mated detection of replicates.
- Implemented a method to automatically find duplicates of spectrum in exponential fit. This is to ease the user intervention for error analysis, if this has been forgotten.
- Implemented the writing out of a "grace2images.py" script file, when performing auto analysis of exponential fits.
- Created the Structure.test_delete_model system test. This is in preparation for extending the structure.delete user function to be able to delete individual structural models. The test will only pass once this functionality is in place.
- Expanded the wiki instructions in the release checklist document. This includes a number of steps for significantly improving the release notes: External links to the Gna! trackers with full descriptions, external links to the HTML user manual for all user functions, internal links to release notes of other relax versions, internal links to wiki pages for all models from all theories, and HTML formatting of all symbols/parameters/etc.
- Introduction of the model argument to the structure.delete user function. This argument is passed all the way into the internal structural object, but is not used yet.
- The model argument in the structure.delete user function is now operational. In the internal object, it has two functions. When the atom_id argument is none, then new ModelList.delete_model() function is being called to remove the entire model from the list of structural models. When the atom_id argument is supplied, then only the corresponding atoms in the given model will be deleted.
- Expanded the checking in the Structure.test_delete_model system test. Now a number of structural model loading and deletion scenarios are tested.
- Implemented back-end function to estimate R
_{x}and I_{0}errors from Jacobian matrix. This is to prepare for user function in relax_fit, to estimate errors. - Implemented user function relax_fit.rx_err_estimate in relax_fit to estimate R
_{x}and I_{0}errors from the Jacobian Co-variance matrix. - Extended system test Relax_fit.test_curve_fitting_height_estimate_error() to test the error estimation method from the Co-variance matrix. The results seems very similar, if increasing to 2000 Monte Carlo simulations.
- Renamed the pipe_control.monte_carlo module to pipe_control.error_analysis. This is in preparation for the module to handle all error analysis techniques: Monte Carlo simulations, covariance matrix, Jackknife simulations, Bootstrapping (which is currently via the Monte Carlo functions), etc. All current functions are now prepended with 'monte_carlo_*()'.
- Fix for the old relax 1.2 model-free results file reading. This is due to the pipe_control.monte_carlo to pipe_control.error_analysis module renaming.
- Implemented the pipe_control.error_analysis.covariance_matrix() function. This follows from http://thread.gmane.org/gmane.science.nmr.relax.scm/23526/focus=7096. It will be used by a new error_analysis.covariance_matrix user function. And it calls the specific API methods model_loop(), covariance_matrix(), and set_error() and the relax library lib.statistics.multifit_covar() function do to most of the work.
- Modified the Relax_fit.test_curve_fitting_height_estimate_error system test. The call to relax_fit.rx_err_estimate has been replaced by the yet-to-be implemented error_analysis.covariance_matrix user function.
- Creation of the error_analysis.covariance_matrix user function. This is simply a code rearrangement. The relax_fit user function module was duplicated and relax_fit.rx_err_estimate renamed to error_analysis.covariance_matrix. References to the specific analysis have been removed.
- Created the specific analysis base API method covariance_matrix(). This defines the arguments required and what is returned by the method. It raises the RelaxImplementError for all analyses which do not implement this method.
- Modified pipe_control.error_analysis.covariance_matrix(). The call to the API covariance_matrix() method now has the model_info argument passed into it. For the relaxation curve-fitting, this allows the loop over spin systems to be skipped.
- Shifted the contents of the specific_analysis.relax_fit.estimate_rx_err module into the API. The estimate_rx_err() function is now the covariance_matrix() method of the specific API. The code for calculating the covariance matrix and errors are now in the function pipe_control.error_analysis.covariance_matrix(), so this has been removed. And the error setting is performed by the set_errors() API method, so that code has been deleted as well.
- Removed the specific_analyses.relax_fit.estimate_rx_err module import. The module has been merged into the specific API module.
- Fix for the pipe_control.error_analysis.covariance_matrix() function. The set_error() API method is parameter specific, so a loop over the parameters using the get_param_names() API method has been added.
- Removed the estimate_rx_err module from the specific_analyses.relax_fit.__all__ list. This module was deleted after merger into the api module.
- Improved the plotting of correlation plot for intensity. Now the intensity to error is plotted, which is the correct measure of this data. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Implemented a correlation plot for R
_{eff}^{2}values to be plotted for different pipes. This has the R_{eff}^{2}/σ_{Reff2}plotted, which is the best way to represent this data. Task #7826: Write a Python class for the repeated analysis of dispersion data. - Further improved the plotting of data in repeated analysis. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Added the Relax_disp.test_show_apod_rmsd_dir_to_files system test to the blacklist. This is if the showApod program is not installed on the machine and allows the test suite to pass.
- Extended the printout for the skipped tests in the test suite. As tests using the NMRPipe showApod software are skipped and listed in this table, the text now includes 'software' in the list.
- Shifted the checks for the Dasha and Modelfree4 software into the system test __init__() method. This is to bring this into the same design as the relaxation dispersion tests which require the NMRPipe showApod software. Now the test suite will list either Dasha or Modelfree4 in the skipped test table if they are not installed.
- Adding another statistic method to plot for multi-data sets. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- More adding of matplotlib snippets for plotting intermediate data. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Changing the range of plotting for statistics. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- More changes to plotting for statistics. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Fix for axis limits when plotting stats. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Fix for globing, to prevent incidentally taking wrong intensity file. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Correction to figure limits. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Implemented writing out of statistics to file. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Adding writing out of PNG files from matplotlib, when looking at statistics. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Another math domain checking, if ref intensity is set to 0.0, then points are skipped, rather than raising an Error. This can happen for extremely bad dispersion data. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Trying implementing flexibility, when data expected data is missing. This can be due failing of processing data, where a whole run of data is randomly skipped. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Better check for math domain error in intensity proportionality. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Removal of initialised of dictionary, before data existence have been checked. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Small fix for correct check of missing of data. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Imported the Numdifftools 0.6.0 package into the relax source tree. This package is extremely useful for testing the implementation of gradients, Hessians, and Jacobians for all relax target functions. The numerical values from numdifftools can be compared to the directly calculated values. And for analysis types where the partial derivatives with respect to each model parameter are too complicated to calculated, or the derivatives are very complicated and hence slow, numdifftools can be used to provide a numerical estimate for direct use in the optimisation. The Numdifftools package is from https://pypi.python.org/pypi/Numdifftools and https://code.google.com/p/numdifftools/. The current version 0.6.0 has been placed into extern/numdifftools. This is only the numdifftools package within the official distribution files and the Python package setup.py file and associated files and directories have not been included. The package uses the New BSD licence (the revised licence with no advertising clause) which is compatible with the GPL v3 licence.
- Reordered functions in repeated analysis protocol. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Added more check of methods to the system test Relax_disp.test_repeat_cpmg(). This actually shows, that user function relax_disp.r20_from_min_r2eff maybe is broken. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Fix for the testing of method is finished when called. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Turned on minimisation in system test Relax_disp.test_repeat_cpmg(). Task #7826: Write a Python class for the repeated analysis of dispersion data.
- The lib.spectrum.nmrpipe module has been made independent of the relax source code. This was discussed at http://thread.gmane.org/gmane.science.nmr.relax.scm/23357/focus=7103. The change allows the software verification tests pass. The dep_check module cannot be used in the relax lib package. Only modules from within lib are allowed to be imported into modules of lib. The fix now allows the full test suite to pass and hence new relax releases are once again possible.
- Created a document which explains how missing copyrights can be found.
- Even more improvements to the shell command for finding missing copyrights.
- Updated the copyright notice for 2014 for all files changed by Edward d'Auvergne. These were identified using the command in the find_missing_copyrights document.
- Added numdifftools to the extern package __all__ list.
- Updated the find_missing_copyrights document. The matching is now more precise and skips all svnmerge operations.
- Added the 2014 copyright notice for Troels Linnet to many relax source files. These were identified as being edited by Troels using the command listed in the find_missing_copyrights document. The changes include adding "Copyright 2014 Troels E. Linnet" to many files not containing Troels' copyright notice, and extending the 2013 copyright to 2014.
- Implemented correlation plot of minimisation values. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Changed the missing package/module/software table in the test suite. This is to allow all names to fit and to update the column titles for software packages.
- Decreased the accuracy of a check in the Relax_disp.test_estimate_r2eff_err_auto system test. This is to allow the test to pass on my Windows 7 VM.
- Added Troels E. Linnet to the COMMITTERS file, which has not been updated in almost 3 years.
- Created the Structure.test_get_model system test. This demonstrates that the internal structural object get_model() method is not working as it should.
- Added a few more checks to the Structure.test_get_model system test.
- Created the Structure.test_collapse_ensemble system test. This is used to test a planned feature of the internal structural object. The collapse_ensemble() method will be created to remove all but one model in the structural ensemble.
- Modified the Structure.test_collapse_ensemble system test to check the initial values. This is for sanity reasons as the test coverage of the structure.add_atom user function is poor.
- Implemented the internal structural object collapse_ensemble() method. This allows the Structure.test_collapse_ensemble system test to pass.
- Created a basic text based progress meter in the new lib.text.progress module. This is taken from the script test_suite/shared_data/frame_order/cam/generate_base.py.
- Modifications to the User_functions.test_structure_add_atom GUI test. As lists of lists are now accepted by the structure.add_atom user function, the operation in the GUI is now significantly different. Therefore many checks have been removed from the GUI test.
- Updated the minimum minfx dependency version number from 1.0.9 to 1.0.11 in the dep_check module. This newest version handles infinite target function values preventing optimisation from continuing forever. The 1.0.10 version is also useful as there is full support for gradients and Hessians in the log-barrier constraint algorithm.
- Shifted the specific_analyses.relax_disp.variables module into lib.dispersion. This is both to minimise circular dependencies, as previously the specific_analyses.relax_disp modules import from target_functions.relax_disp and vice-versa, and to allow the relax library functions to have access to these variables. This follows from a similar change to the frame order analysis in the frame_order_cleanup branch.
- Dependency fix for the auto_analyses.relax_disp_repeat_cpmg module. This was causing relax to fail. SciPy is an optional dependence for relax, but this module caused relax to not start if scipy was not installed. This was detected by testing relax with PyPy.
- Implemented writing out of particular correlation plots to file. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Created a special internal structural object selection object. This will be used for massively speeding up the internal structural object. The use of the lib.selection module by the internal structural object is currently very slow as a huge number of calls to re.search() are required. The idea is to avoid this by using lib.selection once to populate this new selection object, and then reusing this object to loop over molecules and atoms.
- Added the selection() method to the internal structural object. This parses the atom ID string using the lib.selection module, loops over the molecules and atoms, performs matches using re.search() via lib.selection, and populates and returns the new Internal_selection object. This can be used to pre-process the atom ID string to save huge amounts of time.
- The internal structural object validate_models() method now accepts the verbosity argument. This is used to silence printouts.
- Fixes for the new structural object Internal_selection object. The atom indices are not stored via the molecule index.
- Converted the rotate() and translate() structural object methods to use the new selection object. The atom_id arguments have been replaced with selection arguments. Therefore all parts of relax which call these methods must first call selection() to obtain the Internal_selection instance.
- Created the structural object Internal_selection.mol_loop() method. This is to simply quickly loop over all molecule indices of the selection object.
- Converted all structural object methods to use the selection object rather that atom ID strings. This should have a significant impact on the speed of certain operations within relax. The most obvious effect will be a huge speed up of the interatom.define user function. There should be speed ups with a number of other user functions relating to structural information. All parts of relax have been updated for the change.
- Implemented the sampling sparseness instead of NI on the graph axis. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Massive speed up of the internal structural object add_model() method. This speeds up the structure.add_model user function, as well as many internal relax operations on the structural object. Instead of using the copy.deepcopy() function to duplicate an already existing structural model, now new molecule container objects are created and then the individual elements of the original molecule container data lists are copied one by one. This avoids copying a lot of internal Python junk and hence the copying operation is now orders of magnitude faster.
- Created the new --no-skip relax command line option. This is a debugging option specifically designed for relax developers. It allows all blacklisted tests to be executed, i.e. all blacklists are ignored. These tests would normally be skipped, however this option enables them.
- Fix for the test suite summary printout function for the new --no-skip option. The relax status object was clashing with a variable of the same name.
- Reactivated the Relax_disp.test_m61b_data_to_m61b system test, but blacklisted it. This will allow the test to be executed if the --no-skip command line option is used.
- Created the Bmrb.test_bug_22703_display_empty system and GUI test. This system test catches bug #22703, the failure of the bmrb.display user function with an AttributeError when no data is present. It is simultaneously a system and GUI test, as the GUI test class inherits directly from the system test class.
- Created the pipe_control.spectrometer.check_setup() function. This follows the design on the wiki page http://wiki.nmr-relax.com/Relax_source_design. This is for checking if spectrometer information has been set up.
- Created the RelaxNoFrqWarning warning class for warning that no spectrometer information is present.
- Renamed the pipe_control.spectrometer.check_setup() function to check_spectrometer_setup(). This is so it can be used without confusion outside of the module.
- Fix for a broken elif block in the new pipe_control.spectrometer.check_spectrometer_setup() function.
- The model-free bmrb_write() API method now checks for spectrometer information. This is via a call to thepipe_control.spectrometer.check_spectrometer_setup() function.
- Modified the Bmrb.test_bug_22703_display_empty system/GUI test to catch the RelaxNoFrqError.
- Created a special Check class based on the strategy design pattern. This is in the new lib.checks module. The class will be used to simplify and unify all of the check_*() functions in the pipe_control and specific_analyses packages.
- Converted the pipe_control.spectrometer.check_*() functions to the strategy design pattern. These are now passed into the lib.checks.Check object, and the original functions are now instances of this class.
- Alphabetical ordering of all functions in the pipe_control.pipes module.
- Changed the design of the Check object in lib.checks. The design of the checking function to call has been modified - it should now return either None if the check passes or an instantiated RelaxError object if not. This is then used to determine if the __call__() method should return True (when None is received). Otherwise if escalate is set to 1, the text from the RelaxError object is sent into a RelaxWarning and False is returned. And if escalate is set to 2, then the error object is simply raised.
- Updated the pipe_control.spectrometer.check_*_func() functions to use the new design.
- Implemented the writing out of parameter values between comparison of NI level. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Fixes for the lib.checks.Check object. The __call__() method keyword arguments **kargs needs to be processed inside the method to strip out the escalate argument.
- The default value of the escalate argument of the Check.__call__() method is now 2. This will cause the calls to the check_*() function/objects to default to raising RelaxErrors.
- Changed the behaviour of the lib.checks.Check object again. This time the registered function is stored rather than converted into a class instance method. That way the check_*() function-like objects do not need to accept the unused 'self' argument.
- The data pipe testing function has been converted to the strategy design pattern of the Check object. The function pipe_control.pipes.test() has also been renamed to check_pipe().
- Created the Bmrb.test_bug_22704_corrupted_state_file system test. This is to catch bug #22704, the corrupted relax state files after setting the relax references via the bmrb.software, bmrb.display, or bmrb.write user functions.
- Implemented getting the statistics for parameters and comparing to init NI. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Implemented writing and plotting of statistics for individual and clustered fitting, comparing to full NI. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Added checks to the Bmrb.test_bug_22704_corrupted_state_file system test. This is to see if the cdp.exp_info data structure has been correctly restored from the save file.
- Uncommented some checks in the Bmrb.test_bug_22704_corrupted_state_file system test.
- For relaxation dispersion, modified that the grid search and linear constraints for parameter k
_{AB}is between 0-100. The parameter is only used in the TSMFK01 model. The k_{AB}parameter is only for very slow forward exchange rate. The expected values should according to the reference paper: [Tollinger et al., 2001]. The paper concerns values of k_{AB}in the region 0.1 to 5.0. If the exchange rate is any higher value of this, then another model should be used for the analysis. - Set the default insignificance value to 0.0 instead of 1.0. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Modified the grid search limits for parameter k
_{AB}to be between 0.1 and 20.0 rad.s^{-1}. This is for the TSMFK01 model, where values much above 10/20 is not expected. - Implemented counting of outliers for statistics. This is to get a better feeling why some statistics are very much different between NI. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Created the Structure.test_mean system test. This is to test the functionality of a planned new feature, the structure.mean user function. This is an analysis aid that will calculate the mean structure from all loaded models.
- Implemented the structure.mean user function frontend. The backend is currently just a stub function.
- Fixes and simplifications for the pipe_control.pipes.check_pipe() checking object. One of the RelaxError classes were not initialised and the docstring was incorrect.
- Created the pipe_control.structure.main.check_structure() checking object. This will be used for providing much more detailed feedback for when structural information is missing.
- Converted all of the pipe_control.structure.main functions to use the check_structure() object. This standardises and improves all of the checks.
- Some fixes and additional checks for the Structure.test_mean system test.
- Implemented the backend of the structure.mean user function. This primarily occurs within the internal structural object in the new mean() method. The pipe_control.structure.main.mean() function simply checks if the current data pipe is correctly set up and then calls the structural object mean() method.
- Created the Structure.test_align system test. This will be used to test the yet to be implemented structure.align user function. This user function will be similar to the structure.superimpose user function but will be designed so that structures with different primary and atomic sequences can be superimposed.
- Created the frontend of the structure.align user function. This is almost the same as that of the structure.superimpose user function except that the pipes argument has been added and the titles and description changed to indicate the differences.
- Registered the new user function argument type 'int_list_of_lists' in the prompt UI. This is to allow for lists of lists of integers, as used for the model argument in the new structure.align user function.
- Modified the lib.arg_check.is_int_list() function to accept the list_of_lists Boolean argument. This updates the function to have the same functionality as is_str_list(), allows for lists of lists of int to be checked.
- Extended the Structure.test_align system test to throughly check the structural data. This includes changing the structure.align user function call to use 'fit to first' and carefully checking the new atomic coordinates.
- Modified the Structure.test_align system test so that translations and rotations match the algorithm. This allows the output of the structure.align user function to be checked to see if the rotation matrix and translation vector found match that used to shift the original structures.
- Implemented the structure.align user function backend. This is similar to the structure.superimpose user function, however the coordinate data structure only contains atoms which are in common to all structures.
- The pipe_control.structure.main functions translate() and rotate() now accept the pipe_name argument. This is used to translate and rotate structures in different data pipes, as required by the structure.align user function.
- The pipe_control.structure.main.check_structure() checking object now accepts the pipe_name argument. This allows structural data to be checked for in different data pipes without having to switch to them.
- Modified the Structure.test_align system test to call the structure.write_pdb user function. This sets the file name to sys.stdout so that the original structure and the final aligned structures are output to STDOUT for debugging purposes.
- Created the Structure.test_delete_atom system test. This is used to test the deletion of a single atom using the structure.delete user function.
- Expanded the Structure.test_delete_atom system test. This is to show that the structure.write_pdb user function fails after a call to the structure.delete user function to delete individual atoms.
- Fix for the new structure.align user function. The translation and rotation of the structures at the end to the aligned positions was being incorrectly performed.
- Loosened some checks in the Structure.test_align system test to allow it to pass. Some self.assertEqual() checks for the atomic coordinates have been replaced by self.assertAlmostEqual() to allow for small machine precision differences.
- Modified the lib.arg_check.is_str_or_inst() function to handle cStringIO objects. This allows sys.stdout to be used as a file object in the relax test suite.
- Modified the lib.arg_check.is_str_or_inst() function to work with Python 3. Instead of checking for cStringIO.OutputType, which does not exist in Python 3, the argument is simply checked to see if it has a write() method.
- Print out of the number of all R
_{eff}^{2}points, if they are different between analysis. This can become an issue if a single intensity point has slipped into noise, due to low quality of spectrum reconstruction. Task #7826: Write a Python class for the repeated analysis of dispersion data. - Implemented statistics for R
_{eff}^{2}values. Task #7826: Write a Python class for the repeated analysis of dispersion data. - Added data checks and printouts to the structure.align user function. The data checks are to prevent the user from attempting an alignment with differently named molecules, as this will not work.
- Implemented writing out intensity and error correlations plot. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Implemented writing out of intensity statistics. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Expanded the structure.com user function to accept the atom_id argument. This allows the centre of mass (CoM) calculation to be restricted to a certain subset of atoms. The backend already had support for this feature, but now it is exposed in the frontend. The user function docstring has been slightly modified as well.
- Skipping of intensity calculation, if the intensity pipe does not exists. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Added example CPMG data, which could possibly be sent for BMRB submission. The data is un-published CPMG data, related to the paper: Webb H, Tynan-Connolly BM, Lee GM, Farrell D, O'Meara F, Soendergaard CR, Teilum K, Hewage C, McIntosh LP, Nielsen JE (2011). Remeasuring HEWL pK(a) values by NMR spectroscopy: methods, analysis, accuracy, and implications for theoretical pK(a) calculations. Proteins: Struct., Funct., Bioinf. 79(3), 685-702, DOI 10.1002/prot.22886. Task #7858: Make it possible to submit CPMG experiments for BMRB.
- Added system test Relax_disp.test_bmrb_sub_cpmg() to try calling the bmrb functions in relax. Task #7858: Make it possible to submit CPMG experiments for BMRB.
- Implemented the initial part of the API, to collect data for BMRB submission. Task #7858: Make it possible to submit CPMG experiments for BMRB.
- Inserted a "RelaxImplementError" when trying to call bmrb_write from a relaxation dispersion analysis. To implement the function, it would require a re-write of the relax_data bmrb_write(star) function, and proper handling of cdp.ri_ids. It was also not readily possible to find examples of submitted CPMG data in the BMRB database. This makes it hard to develop, and even ensure that BMRB would accept the format. Task #7858: Make it possible to submit CPMG experiments for BMRB.
- Removed the system test Relax_disp.test_bmrb_sub_cpmg() to be tested in the test-suite. This test will not be implemented, as it requires a large re-write of data structures. Task #7858: Make it possible to submit CPMG experiments for BMRB.
- Removed the showing of Matplotlib figures in the test suite. Task #7826: Write a Python class for the repeated analysis of dispersion data.
- Implemented system test Relax_disp.test_dx_map_clustered to catch the missing creation of a point file. Bug #22753: dx.map does not work when only 1 point is used.
- Inserted a check in system test Relax_disp.test_dx_map_clustered, that a call to minimise.calculate should be the same as the file stored with the clustered χ
^{2}value. Bug #22754: The minimise.calculate user function does not calculate χ^{2}value for clustered residues. - Made initial preparation to loop over clustered spins and IDs for the minimise.calculate user function call. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Implemented looping over spin-clusters when issuing a minimise.calculate. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Made back_calc_r2eff() in optimisation module use the spin and ID list instead. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Fix for graph plotting functionality to send spins as list of one spins. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Fix for calling back_calc_r2eff with the new argument keywords, and use list of spin and spin IDs. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Fix for synthetic script calling back_calc_r2eff() with old arguments and to use list of spin containers and IDs. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Inserted last test in test_dx_map_clustered, to check out the written χ
^{2}values are as expected. Bug #22754: The minimise.calculate user function does not calculate χ^{2}value for clustered residues. - Moved the looping over cluster spin IDs into its own function in the API. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Added the selection string for all the cluster IDs to be parsed back as well. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Made the value set function, set values to all spins, if it is a global parameter. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Moved the skipping of protons away from looping function. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Inserted some testing lines for making a dx_map, either global clustered or as a free spin. There is a big difference which dx map you get. It illustrates beautifully the effect of clustering things together. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Added a BMRB NMR-STAR formatted deposition file for the OMP model-free data for reference. This is because there are no other NMR-STAR formatted files in the relax sources.
- In the dispersion API calculate(), used the API function model_loop() to loop over the clusters instead. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Removed then function loop_cluster_ids() from dispersion API(). This should be implemented elsewhere. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Updated the API set_param_values() function to use model_loop() to get the spin_ids from the cluster. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Initial try to fix unit test test_value_set_r1_rit(). The problem is that no spin ID can be generated since the spins are created manually. "AttributeError: 'MoleculeContainer' object has no attribute '_res_name_count' ". Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Removed the checking of MODEL_LIST_MMQ, and spin.isotope from optimisation.back_calc_r2eff(), since this check is already covered. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Fix for references to "spin" in optimisation.back_calc_r2eff(). Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Fix for looping performed twice in relax_disp API model_loop(). Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Removed unused proton reference in relax_disp API calculate(). There is though some problems with these tests (F 1.93 s for Relax_disp.test_korzhnev_2005_15n_dq_data, F 2.01 s for Relax_disp.test_korzhnev_2005_1h_mq_data, F 1.93 s for Relax_disp.test_korzhnev_2005_1h_sq_data). It is unsure where these comes from. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Fix for epydoc in system test Relax_disp.test_dx_map_clustered.
- Updated all of the Relax_disp.test_korzhnev_2005_*_data system tests. These now have slightly changed parameter values due to the fix of bug #22563, the NS MMQ 2-site dispersion model running at 32-bit precision and not 64-bit as it should be.
- Epydoc change for DOI reference in system tests. Bug #22754: The minimise.calculate user function does not calculate χ
^{2}value for clustered residues. - Added some test PyMOL scripts to create OpenDX maps and χ
^{2}surface plots. These will go to the wiki: http://wiki.nmr-relax.com/Chi2_surface_plot. - Big improvement for running the relax unit tests via the relax command line options. The unit test module path is now accepted as a command line option. This brings more capabilities of Gary Thompson's test_suite/unit_tests/unit_test_runner.py script into the relax command line. The _pipe_control/test_value unit test module path can be specified as, for example, one of 'test_suite.unit_tests._pipe_control.test_value', 'test_suite/unit_tests/_pipe_control/test_value', '_pipe_control.test_value', '_pipe_control/test_value'. This allows individual modules of tests to be run, rather than having to execute all unit tests, which is very useful for debugging.
- Modified the printouts for the unit tests when running with the --time command line option. The test name is now being processed. The leading 'test_suite.unit_tests.' text is now stripped out. And the remaining text is split into the module name and the test name. This is to allow the unit test module name to be more easily identifiable, so it can then be used as a command line option to allow only a subset of tests to be performed.
- Modified the help strings for the test suite options shown when 'relax -h' is run. The ability to specify individual tests (or modules of tests for the unit tests) is now documented. The '--time' option help string has also been edited.
- Fix for the Bmrb.test_bug_22704_corrupted_state_file GUI test. This was failing because the setUp() method in the inherited Bmrb system test module was being overwritten by the default Unittest.setUp() method. Therefore the system test setUp() method has been copied into the GUI test class.
- Fix for the Test_value.test_value_set_r1_rit test of the _pipe_control.test_value unit test module. This is a general fix for all unit test modules which use the test_suite.unit_tests.value_testing_base.Value_testing_base base class. After the molecules, residues and spins are manually created, the pipe_control.mol_res_spin.metadata_update() function is called to make sure that all of the private and volatile metadata have been correctly created, so that the other pipe_control.mol_res_spin module functions can operate correctly.
- Removal of repetitive code in the relaxation dispersion model_loop() API method. The spin loop does not need to be called twice, instead the if statements have been modified to better direct the code execution.
- Added script to simulate dispersion profiles at different settings. This shows that something is wrong. The back-calculated values in the graphs are not equal to the interpolated values. There must be something wrong somewhere. This list shows the χ
^{2}values and, judging from the dispersion graphs, this simply cannot be true. - Changed bounds for sample scripts to create: 3D iso-surface plot, surface plot and simulation of dispersion curves.
- Minor changes to Python matplotlib script, to produce surface plot. Also added the new data for the plotting.
- Modified the example data, after issue with parameters was fixed.

### relax 3.3.0

- Improved model handling for the internal structural object. The set_model() method has been added to allow either a model number to be set to the first unnumbered model (in preparation for adding new models) or to allow models to be renumbered. The logic of the add_model() has also been changed. Rather than looping over all atoms of the first model and copying them, which does not work due to the model validity checks, the entire MolList (molecule list) data structure is copied using copy.deepcopy() to make a perfect copy of the structural data. The ModelList.add_item() method has also been modified to return the newly added or numbered model. This is used by the add_model() structural object method to obtain the model object.
- Updated the Mac OS X framework setting up instruction document. New sections have been added for the nose and matplotlib Python packages, as nose is needed for the numpy and scipy testing frameworks and matplotlib might be a useful optional dependency in the future. The mpy4py section has been updated to avoid the non-framework fink version of mpicc which cannot produce universal binaries. A few other parts also have small edits.
- Removed the Freecode section from the release checklist as Freecode has been permanently shut down. The old relax links are still there (http://freecode.com/projects/nmr-relax), but Freecode is dead (http://freecode.com/about).
- Fix for the internal structural object MolContainer.last_residue() method. This can now operate when no structural information is present, returning 0 instead of resulting in an IndexError.
- Updated the script for finding unused imports in the relax source code. Now the file name is only printed for Python files which have unused imports.
- Completely removed all mentions of Freecode from the release document. The old relax links are still there, but Freecode is dead.
- Updated the minfx version in the release checklist document to 1.0.8. This version has not been released yet, but it will include important fixes and additions for constrained parallelised grid searches.
- Fix for a broken link in the development chapter of the relax manual.
- Fixes for dead hyperlinks in the relaxation dispersion chapter of the relax manual. The B14 model links to http://www.nmr-relax.com/api/3.2/lib.dispersion.b14-module.html were broken as the B in B14 was capitalised.
- Sent in the verbosity argument value to the minfx.grid.grid_split() function. 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.
- The time user function now uses the chronometer Oxygen icon in the GUI.
- Removed the line wrapping in the epydoc parameter section of the optimisation function docstrings. This is for the pipe_control.minimise module.
- More docstring line wrapping removal from pipe_control.minimise.
- Bug fix for the parameter units descriptions. This only affects a few rare parameters. The specific analysis API parameter object units() method was incorrectly checking if the units value is a function - it was checking the parameter conversion factor instead.
- Modified the align_tensor.init user function so that the parameters are now optional. This allows alignment tensors to be initialised without specifying the parameter values for that tensor.
- Modified profiling script to have different number of NCYC points per frequency. This is to complicate the data, so any erroneous reshaping of data is discovered. It is expected, that experiments can have different number of NCYC points per spectrometer frequency. Task #7807: Speed-up of dispersion models for clustered analysis.
- Initial try to alter the target function calc_CR72_chi2. This is the first test to restructure the arrays, to allow for higher dimensional computation. All numpy arrays have to have same shape to allow to multiply together. The dimensions should be [ei][si][mi][oi][di]. [Experiment][spins][spec. frq][offset][disp points]. This is complicated with number of disp point can change per spectrometer frequency. Task #7807: Speed-up of dispersion models for clustered analysis. This implementation brings a high overhead. The first test shows no winning of time. The creation of arrays takes all the time.
- Temporary changed the lib/dispersion/cr72.py function to unsafe state. This change turns-off all the safety measures, since they have to be re-implemented for higher dimensional structures.
- Altered profiling script to report cumulative timings and save to temporary files. Task #7807: Speed-up of dispersion models for clustered analysis. This indeed shows that the efficiency has gone down.
- Added print out of χ
^{2}to profile script. Task #7807: Speed-up of dispersion models for clustered analysis. - Moved the creation of special numpy structures outside target function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified profiling script to calculate correct values when setting up R
_{2eff}values. This is to test, that the return of χ^{2}gets zero. Task #7807: Speed-up of dispersion models for clustered analysis. - Removing looping over exp and offset indices in calc_chi2. They are always 0 anyway. This brings a little speed. Task #7807: Speed-up of dispersion models for clustered analysis.
- In profiling script, moved up the calculation of values one level. This is to better see the output of the profiling iterations for CR72.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for calculation of the Larmor frequency per spin in profiling script. The frq loop should also be up-shifted. It was now extracted as 0.0. Task #7807: Speed-up of dispersion models for clustered analysis.
- Re-inserted safety checks in lib/dispersion/CR72.py file. This is re-inserted for the rank_1 cases. This makes the unit-tests pass again. Task #7807: Speed-up of dispersion models for clustered analysis.
- Important fix for extracting the correct shape to create new arrays. If using just one field, or having the same number of dispersion points, the shape would extend to the dispersion number. It would report [ei][si][mi][oi][di] when calling ndarray.shape. Shape always has to be reported as: [ei][si][mi][oi]. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made it easier to switch between single and cluster reporting in profiling script. Task #7807: Speed-up of dispersion models for clustered analysis.
- Important fix for the creation of the multi dimensional p
_{A}numpy array. It should be created as numpy.zeros([ei][si][mi][oi]) instead of numpy.ones([ei][si][mi][oi]). This allows for rapid testing of all dimensions with np.allclose(pA, numpy.ones(dw.shape)). p_{A}can have missing filled out values, when the number of dispersion points are different per spectrometer frequency. Task #7807: Speed-up of dispersion models for clustered analysis. - Added unit tests demonstrating edge cases 'no Rex' failures of the model CR72 full, for a clustered multi dimensional calculation. This is implemented for one field. This is to implement catching of math domain errors, before they occur. These tests cover all parameter value combinations which result in no exchange: Task #7807: Speed-up of dispersion models for clustered analysis.
- Re-implemented safety checks in lib/dispersion/cr72.py. This is now implemented for both rank-1 float array and of higher dimensions. This makes the unit tests pass for multi dimensional computing. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added unit tests demonstrating edge cases 'no Rex' failures of the model CR72 full, for a clustered multi dimensional calculation. This is implemented for three fields. This is to implement catching of math domain errors, before they occur. These tests cover all parameter value combinations which result in no exchange: Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed that special numpy structure is also created for CR72. This makes most system tests pass. Task #7807: Speed-up of dispersion models for clustered analysis.
- Critical fix for the slicing of values in target function. This makes system test: Relax_disp.test_sod1wt_t25_to_cr72 pass. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added self.has_missing keyword in initialization of the Dispersion class. This is to test once, per spin or cluster. This saves a looping over the dispersion points, when collection the data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Created multi dimensional error and value numpy arrays. This is to calculate the χ
^{2}sum much faster. Reordered the loop over missing data points, so it is only initiated if missing points is detected. Task #7807: Speed-up of dispersion models for clustered analysis. - Switch the looping from spin->frq to frq->spin. Since the number of dispersion points are the same for all spins, this allows to move the calculation of p
_{A}and k_{ex}array one level up. This saves a lot of computation. Task #7807: Speed-up of dispersion models for clustered analysis. - Changed all the creation of special numpy arrays to be of float64 type. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the data filling of special numpy array errors and values, to initialization of Dispersion class. These values does not change, and can safely be stored outside. Task #7807: Speed-up of dispersion models for clustered analysis.
- Just a tiny little more speed, by removing temporary storage of χ
^{2}calculation. Task #7807: Speed-up of dispersion models for clustered analysis. - Made copies of numpy arrays instead of creating from new. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added a self.frqs_a as a multidimensional numpy array. Task #7807: Speed-up of dispersion models for clustered analysis.
- Small fix for the indices to the errors and values numpy array. Task #7807: Speed-up of dispersion models for clustered analysis.
- Lowered the number of iterations to the profiling scripts. This is to use the profiling script as bug finder. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the calculation of dw_frq out of spin and spectrometer loop. This is done by having a special 1/0 spin numpy array, which turns on or off the values in the numpy array multiplication. The multiplication needs to first axis expand Δω, and then tile the arrays according to the numpy structure. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the calculation of p
_{A}and k_{ex}out off all loops. This was done by having two special 1/0 spin structure arrays. Task #7807: Speed-up of dispersion models for clustered analysis. - Removed dw_frq_a numpy array, as it was not necessary. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed all looping over spin and spectrometer frequency. This is the last loop! Wuhu. Task #7807: Speed-up of dispersion models for clustered analysis.
- Reordered arrays for beauty of code. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made the back_calc array be initiated as copy of the values array. Task #7807: Speed-up of dispersion models for clustered analysis.
- Small edit to profiling script, to help bug finding. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fixed that arrays are correctly initiated with one or zero values. Task #7807: Speed-up of dispersion models for clustered analysis.
- Very important fix, for only replacing part of data array which have Nan values. Before, all values were replaced, which was wrong. Task #7807: Speed-up of dispersion models for clustered analysis.
- Needed to increase the relative tolerance when testing if p
_{A}array is 1. Now system test Relax_disp.test_hansen_cpmg_data_missing_auto_analysis passes. Also added some comments lines, to prepare for mask replace of values. For example if only some of etapos values should be replaced. Task #7807: Speed-up of dispersion models for clustered analysis. - Restored profiling script to normal. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made the logic and comments much clearer about how to reshape, expand axis, and tile numpy arrays. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented a masked array search for where "missing" array is equal 1. This makes it possible to replace all values with this mask, from the value array. This eliminates the last loops over the missing values. It took over 4 hours to figure out, that the mask should be called with mask.mask, to return the same fulls structure, Task #7807: Speed-up of dispersion models for clustered analysis.
- Yet another small improvement for the profiling script. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed the multi dimensional structure of p
_{A}. p_{A}is not multi-dimensional, and can just be multiplied with numpy arrays. Task #7807: Speed-up of dispersion models for clustered analysis. - Fix for testing of p
_{A}in lib function, when p_{A}is just float. Task #7807: Speed-up of dispersion models for clustered analysis. - Modified unit tests, so p
_{A}is sent to target function as float instead of array. Task #7807: Speed-up of dispersion models for clustered analysis. - Removed the multi dimensional structure of k
_{ex}. k_{ex}is not multi-dimensional, and can just be multiplied with numpy arrays. Task #7807: Speed-up of dispersion models for clustered analysis. - Fix for testing of k
_{ex}in lib function, when k_{ex}is just float. Task #7807: Speed-up of dispersion models for clustered analysis. - Modified unit tests, so k
_{ex}is sent to target function as float instead of array. Task #7807: Speed-up of dispersion models for clustered analysis. - Important fix for replacing values if eta_pos > 700 is violated. This fixes system test: Relax_disp.test_sod1wt_t25_to_cr72, which failed after making k
_{ex}to a numpy float. The trick is to make a numpy mask which stores the position where to replace the values. Then replace the values just before last return. This makes sure, that not all values are changed. Task #7807: Speed-up of dispersion models for clustered analysis. - Increased the k
_{ex}speed to 1e^{7}in clustered unit tests cases. This is to demonstrate where there will be no excange. Task #7807: Speed-up of dispersion models for clustered analysis. - Added a multi-dimensional numpy array χ
^{2}value calculation function. Task #7807: Speed-up of dispersion models for clustered analysis. - Called the newly created χ
^{2}function to calculate for multi dimensional numpy arrays. Task #7807: Speed-up of dispersion models for clustered analysis. - Renamed chi2_ND to chi2_rankN. This is a better name for representing multiple axis calculation. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made special ei, si, mi, and oi numpy structure array. This is for rapid speed-up of numpy array creation in target function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced self.spins_a with self.disp_struct. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made initialisation structures for Δω. Task #7807: Speed-up of dispersion models for clustered analysis.
- Initial try to reshape Δω faster. Task #7807: Speed-up of dispersion models for clustered analysis.
- Switched to use self.ei, self.si, self.mi, self.oi, self.di. This is for better reading of code. Task #7807: Speed-up of dispersion models for clustered analysis.
- Comment out the sys.exit(), which would make the code fail for wrong calculation of Δω. Task #7807: Speed-up of dispersion models for clustered analysis.
- Copied profiling script for CPMG model CR72 to R
_{1ρ}DPL94 model. The framework of the script will be the same, but the data a little different. Task #7807: Speed-up of dispersion models for clustered analysis. - Started converting profiling script to DPL94. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced self.(ei,si,mi,oi,di) with self.(NE,NS,NM,NO,ND). These numbers represents the maximum number of dimensions, instead of index. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added the ei index, when creating the first dw_mask. Task #7807: Speed-up of dispersion models for clustered analysis.
- Reordered how the structures Δω init structures are created. Task #7807: Speed-up of dispersion models for clustered analysis.
- Clearing the dw_struct before calculation. Task #7807: Speed-up of dispersion models for clustered analysis.
- Started using the new way of constructing Δω. This is for running system tests. Note, somewhere in the Δω array, the frequencies will be different between the two implementations. But apparently, this does not matter. Task #7807: Speed-up of dispersion models for clustered analysis.
- Inserted temporary method to switch for profiling. Task #7807: Speed-up of dispersion models for clustered analysis.
- First try to speed-up the old Δω structure calculation. Task #7807: Speed-up of dispersion models for clustered analysis.
- Simplified calculation. Task #7807: Speed-up of dispersion models for clustered analysis.
- Yet another try to implement a fast Δω structure method. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented the fastest way to calculate the Δω structure. This uses the numpy ufunc multiply.outer function to create the outer array, and then multiply with the frqs_structure. Task #7807: Speed-up of dispersion models for clustered analysis.
- Renamed Δω temporary structure to generic structure. Task #7807: Speed-up of dispersion models for clustered analysis.
- Restructured the calculation of R
_{2A}^{0}and R_{2B}^{0}to the most efficient way. Task #7807: Speed-up of dispersion models for clustered analysis. - Made the lib/dispersion/CR72.py to a numpy multi dimensional numpy array calculation. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed the catching when Δω is zero, to use masked array. Implemented backwards compatibility with unit tests. Task #7807: Speed-up of dispersion models for clustered analysis.
- Bugfix for testing if k
_{ex}is zero. It was tested if k_{ex}was equal 1.0. Task #7807: Speed-up of dispersion models for clustered analysis. - Implemented masked replacement if fact is less that 1.0. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced isnan mask with function that catches all invalid values.
- Removed the masked replacement if fact is less than 1.0. This is very strange, but otherwise system test: Relax_disp.test_hansen_cpmg_data_missing_auto_analysis would fail. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed the slow allclose() function to test if R
_{2A}^{0}and R_{2B}^{0}is equal. It is MUCH faster to just subtract and check sum is not 0.0. Task #7807: Speed-up of dispersion models for clustered analysis. - Replaced the temporary variable R
_{2eff}with back_calc, and used numpy subtract to speed up. Task #7807: Speed-up of dispersion models for clustered analysis. - Made the lib function into a pure numpy array calculation. This requires, that R
_{2A}^{0}, R_{2B}^{0}and Δω has same dimension as the dispersion points. Task #7807: Speed-up of dispersion models for clustered analysis. - Changes too unit tests, so data is sent to target function in numpy array format. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed the creation of an unnecessary structure by using numpy multiply. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the mask which finds where to replace values into the __init__ function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Copied profiling script for CR72 to B14 model. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified profiling script for the B14 model. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified model B14 lib file to faster numpy multidimensional mode. The implementations comes almost directly from the CR72 model file. Task #7807: Speed-up of dispersion models for clustered analysis.
- Reverted the use of the mask "mask_set_blank". It did not work, and many system tests started failing. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed the target function to handle the B14 model for faster numpy computation. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed unit test for B14 to match numpy input requirement. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added additional tests in B14, when math errors can occur. This is very easy with a conditional masked search in arrays. Task #7807: Speed-up of dispersion models for clustered analysis.
- Comment fix for finding when E0 is above 700 in lib function of B14. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed use of "asarray", since the variables are already arrays. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed target function for model CR72. To CR72 is now also the input of the parameters of R
_{2A}^{0}, R_{2B}^{0}and Δω. Δω is tested for zero, to return flat lines. It is faster to search in the smaller numpy array, than the 5 dimensional Δω array. This is for speed-up. R_{2A}^{0}and R_{2B}^{0}is also subtracted, to see if the full model should be used. In the same way, it is faster to subtract the smaller array. These small tricks are expected to give 5-10 pct. speeed-up. Task #7807: Speed-up of dispersion models for clustered analysis. - Made the lib function of CR72 accept the R
_{2A}^{0}, R_{2B}^{0}and Δω of the original array. This is for speed-up. Task #7807: Speed-up of dispersion models for clustered analysis. - Changed unit-tests, to send in the original R
_{2A}^{0}, R_{2B}^{0}and dw_orig to the testing of the lib function CR72. Task #7807: Speed-up of dispersion models for clustered analysis. - Changed profiling script to send R
_{2A}^{0}, R_{2B}^{0}and Δω, as original parameters to the lib function. Task #7807: Speed-up of dispersion models for clustered analysis. - Changed target function for model B14. To B14 now also send the input of the original parameters Δω. Δω is tested for zero, to return flat lines. It is faster to search in the smaller numpy array, than the 5 dimensional Δω array. This is for speed-up. These small tricks are expected to give 5-10 pct. speed-up. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made the lib function of B14 accept Δω of the original array. This is for speed-up. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed unit-tests, to send in the original dw_orig to the testing of the lib function B14. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed profiling script to send Δω as original parameters to the lib function B14. Task #7807: Speed-up of dispersion models for clustered analysis.
- Copied profiling script for CR72 model to TSMFK01 model. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified profiling script to be used for model TSMFK01. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified target function for model TSMFK01, to send in Δω as original parameter. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified lib function for model TSMFK01 to accept dw_orig as input and replaced functions to find math domain errors into maske replacements. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made unit tests for model TSMFK01 send in R
_{2A}^{0}and Δω as a numpy array. Task #7807: Speed-up of dispersion models for clustered analysis. - Large increase in speed for model TSMFK01 by changing target functions to use multidimensional numpy arrays in calculation. This is done by restructuring data into multidimensional arrays of dimension [NE][NS][NM][NO][ND], which are number of spins, number of magnetic field strength, number of offsets, maximum number of dispersion point. The speed comes from using numpy ufunc operations. The new version is 2.4X as fast per spin calculation, and 54X as fast for clustered analysis.
- Replacing math domain checking in model DPL94, with masked array replacement. Task #7807: Speed-up of dispersion models for clustered analysis.
- First try to speed up model DPL94. This has not succeeded, since system test: Relax_disp.test_dpl94_data_to_dpl94 still fails. Task #7807: Speed-up of dispersion models for clustered analysis.
- Trying to move some of the structures into its own part. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for forgetting to multiply frqs to power 2. This was found by inspecting all print out before and after implementation. New implementation of DPL94 now passes all system and unit tests. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the expansion of the R
_{1}structure out of the for loops. This is to speed-up the __init__ of the class of the target function. Task #7807: Speed-up of dispersion models for clustered analysis. - Moved the packing of errors and values out of for loop in the __init__ class of target function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the multi dimensional expansion of inv_relax_times out of for loop. This can be done for all structures, which does not have missing points. Task #7807: Speed-up of dispersion models for clustered analysis.
- For inv_relax_times, expanded one axis, and tiled up to NR spins, before reshaping and blowing up to full structure. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the expansion of frqs out of for loops. Task #7807: Speed-up of dispersion models for clustered analysis.
- Documentation fix for description of input arrays to lib functions. Task #7807: Speed-up of dispersion models for clustered analysis.
- Converted TAP03 model to use multi dimensional numpy arrays. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made Δω in unit tests of TAP03 be of numpy array. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced the loop structure in target function of TAP03 with numpy arrays. This makes the model faster. Task #7807: Speed-up of dispersion models for clustered analysis.
- Reordered the initialization structure of the special numpy arrays. This was done in the init part of the target function of relaxation dispersion. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added model MODEL_TSMFK01 also get self.tau_cpmg calculated in init part. Task #7807: Speed-up of dispersion models for clustered analysis.
- Methods to replace math domain errors in model TP02, has been replaced with numpy masks. Documentation is also fixed. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for sending in Δω as numpy array in unit tests of model TP02. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced target function for model TP02, to use higher dimensional numpy array structures. That makes the model much faster. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for adding model TP02 to part of init class to initialize preparation of higher dimension numpy structures. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made the NOREX model a faster numpy array calculation. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed an unnecessary frq_struct in init of target function. frqs can just be expanded, and back_calc is cleaned afterwards with disp_struct. Task #7807: Speed-up of dispersion models for clustered analysis.
- Methods to replace math domain errors in model M61, has been replaced with numpy masks. Documentation is also fixed. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for sending in r1rho_prime and phi_ex_scaled as numpy array in unit tests of model M61. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced target function for model M61, to use higher dimensional numpy array structures. That makes the model much faster. Task #7807: Speed-up of dispersion models for clustered analysis.
- Methods to replace math domain errors in model M61b, has been replaced with numpy masks. Documentation is also fixed. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for sending in r1rho_prime and Δω as numpy array in unit tests of model M61b. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced target function for model M61b, to use higher dimensional numpy array structures. That makes the model much faster. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed number of points to be send to lib function of model TSMFK01. These are not used anymore. Also removed in corresponding unit tests. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed number of points and p
_{B}to be send to lib function of model TP02. Number of points are not used anymore. p_{B}is calculated in lib function instead. Also removed in corresponding unit tests. Task #7807: Speed-up of dispersion models for clustered analysis. - Removed number of points and p
_{B}to send to lib function of model TP02. p_{B}is calculated in lib function instead. Task #7807: Speed-up of dispersion models for clustered analysis. - Removed number of points, p
_{B}, k_{AB}, k_{BA}to be send to lib function of model B14. Number of points are not used anymore. p_{B}is calculated in lib function instead. k_{AB}, and k_{BA}are calculated in lib functions instead. Fixed in target function. Fixed in lib function. Fixed in corresponding unit tests. Task #7807: Speed-up of dispersion models for clustered analysis. - Fix for sending number of points in target function of TSMFK01. This was removed in lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed number of points, p
_{B}, to be send to lib function of model TAP03. Number of points are not used anymore. p_{B}is calculated in lib function instead. Fixed in target function. Fixed in lib function. Fixed in corresponding unit tests. Task #7807: Speed-up of dispersion models for clustered analysis. - Removed number of points, to be send to lib function of model CR72. Number of points are not used anymore. Fixed in target function. Fixed in lib function. Fixed in corresponding unit tests. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed number of points, to be send to lib function of model DPL94. Number of points are not used anymore. Fixed in target function. Fixed in lib function. Fixed in corresponding unit tests. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed number of points, to be send to lib function of model M61. Number of points are not used anymore. Fixed in target function. Fixed in lib function. Fixed in corresponding unit tests. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed number of points, to be send to lib function of model M61b. Number of points are not used anymore. Fixed in target function. Fixed in lib function. Fixed in corresponding unit tests. Task #7807: Speed-up of dispersion models for clustered analysis.
- Methods to replace math domain errors in model MP05, has been replaced with numpy masks. Number of points has been removed, as the masks utility replaces this. Calculation of p
_{B}, has been moved to lib function for simplicity. Documentation is also fixed. Task #7807: Speed-up of dispersion models for clustered analysis. - Fix for sending in Δω as numpy array in unit tests of model MP05. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced target function for model MP05, to use higher dimensional numpy array structures. That makes the model much faster. Task #7807: Speed-up of dispersion models for clustered analysis.
- Methods to replace math domain errors in model LM63, has been replaced with numpy masks. Number of points has been removed, as the masks utility replaces this. Documentation is also fixed. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for sending in number of points in unit tests of model LM63. Task #7807: Speed-up of dispersion models for clustered analysis. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced target function for model LM63, to use higher dimensional numpy array structures. That makes the model much faster. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for replacement of values with mask, when φ
_{ex}is zero. This can be spin specific. System test: Relax_disp.test_hansen_cpmg_data_to_lm63 starts to fail: Task #7807: Speed-up of dispersion models for clustered analysis. - Fix for sending in R
_{2}^{0}and φ_{ex}as numpy array in unit tests of LM63. This is after using masks as replacement. Task #7807: Speed-up of dispersion models for clustered analysis. - 1 digit decrease in parameter check in system test: Relax_disp.test_hansen_cpmg_data_to_lm63. It is unknown, why this has occurred. Task #7807: Speed-up of dispersion models for clustered analysis.
- Methods to replace math domain errors in model IT99, has been replaced with numpy masks. Number of points has been removed, as the masks utility replaces this. p
_{B}is now moved to be calculated inside. This makes the lib function simpler. Documentation is also fixed. Task #7807: Speed-up of dispersion models for clustered analysis. - Fix for sending in R
_{2}^{0}and Δω as numpy array in unit tests of IT99. This is after using masks as replacement. Task #7807: Speed-up of dispersion models for clustered analysis. - Replaced target function for model IT99, to use higher dimensional numpy array structures. That makes the model much faster. Task #7807: Speed-up of dispersion models for clustered analysis.
- Methods to replace math domain errors in model ns_cpmg_2site_expanded, has been replaced with numpy masks. Number of points has been removed, as the masks utility replaces this. p
_{B}is now moved to be calculated inside. This makes the lib function simpler. k_{AB}and k_{BA}is also now calculated here. Documentation is also fixed. Task #7807: Speed-up of dispersion models for clustered analysis. - Fix for sending in R
_{2}^{0}and Δω as numpy array in unit tests of ns_cpmg_2site_expanded. This is after using masks as replacement. Task #7807: Speed-up of dispersion models for clustered analysis. - Replaced target function for model ns_cpmg_2site_expanded, to use higher dimensional numpy array structures. That makes the model much faster. I cannot get system test: Relax_disp.test_cpmg_synthetic_dx_map_points to pass. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for system test Relax_disp.test_cpmg_synthetic_dx_map_points. By just copying self.back_calc_a to self.back_calc, problem was solved. In specific_analysis.relax_disp.optimisation in function back_calc_r2eff(), the function gets the last values stores in the class function. This is in "class Disp_result_command(Result_command)" with self.back_calc = back_calc. And back_calc_r2eff() have return model.back_calc. Task #7807: Speed-up of dispersion models for clustered analysis.
- Methods to replace math domain errors in model ns_cpmg_2site_3d, has been replaced with numpy masks. Number of points has been removed, as the masks utility replaces this. p
_{B}is now moved to be calculated inside. This makes the lib function simpler. k_{AB}and k_{BA}is also now calculated here. Magnetization vector is also now filled in lib function. Task #7807: Speed-up of dispersion models for clustered analysis. - Fix for unit tests of model NS CPMG 2-site 3D to the reduced input to the lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Change to the target function to the model NS CPMG 2-site 3D to use the reduced input to the lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed linked matrix/vector inner products into chained dot expressions. Task #7807: Speed-up of dispersion models for clustered analysis.
- Wrote the essential dot matrix up to be initiated earlier. Task #7807: Speed-up of dispersion models for clustered analysis.
- Lowered the number of dot iterations, by pre-prepare the dot matrix another round. Task #7807: Speed-up of dispersion models for clustered analysis.
- Turned Mint vector into a 7,1 matrix, so dimensions fit with evolution matrix. Task #7807: Speed-up of dispersion models for clustered analysis.
- Lowered the number of dot operations, by pre-preparing the evolution matrix another round. The power is in system tests always even. The trick to removing this for loop, would be to make a general multi dot function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the bulk operation of model NS CPMG 2-site 3D into the lib file. This is to keep the API clean. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed the unit test of NS CPMG 2-site 3D, after the input to the function has changed. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed the target function for NS CPMG 2-site 3D. This reflects the new API layout. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed the lib function of NS CPMG 2-site star, to get input of Δω and R
_{2A}^{0}+R_{2B}^{0}of higher dimensional type. This is to move the main operations from the target function to the lib function, and make the API code clean and consistent. Task #7807: Speed-up of dispersion models for clustered analysis. - Changed the target function of NS CPMG 2-site star, to reflect the input to the function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made the dot evolution structure faster for NS CPMG 2-site 3D. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented the BLAS method of dot product, which should be faster. I cannot get the "out" argument to work. Task #7807: Speed-up of dispersion models for clustered analysis.
- Small fix for the dot method. But the out argument does not work. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented the dot method via blas. This needs a array with one more axis. Task #7807: Speed-up of dispersion models for clustered analysis.
- Last try to use the out argument. In the last dotting loop, the out argument wont work, no matter what I do. Task #7807: Speed-up of dispersion models for clustered analysis.
- Inner product fix in model NS CPMG 2-site 3D. Fix for system tests: Relax_disp.test_cpmg_synthetic_ns3d_to_b14, Relax_disp.test_cpmg_synthetic_ns3d_to_CR72, Relax_disp.test_cpmg_synthetic_ns3d_to_CR72_noise_cluster. The number of dotting with Mint, should correspond to the power. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced the temporary structure self.frqs_a to self.frqs, which works for all target functions. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced the temporary structure self.cpmg_frqs_a to self.cpmg_frqs, which works for all target functions. Task #7807: Speed-up of dispersion models for clustered analysis.
- Restructured all data structures into higher dimension in target function. Fix for the input to the different models. Restructured how to detect the number of offset and dispersion points. Task #7807: Speed-up of dispersion models for clustered analysis.
- Various index fixes, after the data structures have been reordered. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for unit test, where the dimension of points has to be one lower. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for plotting, since the back_calc now can hold more data points that cpmg frequencies. This is because the numpy array has been expanded to the maximum number of points. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented a frqs_squared calculation in the init of target function. This is to speed up the calculations. Task #7807: Speed-up of dispersion models for clustered analysis.
- Restructured frqs_H to higher dimension in target function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the calculation of Δω and Δω
_{H}out of for loops for model MMQ CR72. Task #7807: Speed-up of dispersion models for clustered analysis. - Removed looping over spin and frequencies for model MMQ CR72. Task #7807: Speed-up of dispersion models for clustered analysis.
- Temporary removed check for Δω = 0.0 in MMQ CR72. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed number of points to be parsed to model MMQ CR72. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed power to be parsed to MMQ CR72, since it is not used. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed MMQ CR72 to use multi dimensional data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed unit test of MMQ CR72 to pass. Δω needs to be of numpy structure. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the calculation of Δω out of for loops for model NS MMQ 2-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified lib function for NS MMQ 2-site, to have looping over spins and frequencies inside lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fixed the use of higher dimensional data in NS MMQ 2-site SQ DQ ZQ. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for documentation in NS MMQ 2-site/SQ/DQ/ZQ/MQ. Now explains which dimension data should be in. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changed the reshaping of Δω and Δω
_{H}, since it is not dependent on experiment. Task #7807: Speed-up of dispersion models for clustered analysis. - Changed the calculation of inner product in model NS CPMG 2-site 3D. The out argument of numpy.dot is buggy, and should not be used. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added missing instances of cleaning the data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Bug fix for model LM63 3-site. The index si has to be used to extract data to lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Temporary added system test: test_korzhnev_2005_all_data_disp_speed_bug. This makes a minimisation with 1 iteration, and so will give the χ
^{2}value at the preset parameter values. This is χ^{2}value should give 162.5, but gives 74.7104. Task #7807: Speed-up of dispersion models for clustered analysis. - Updated documentation on dimensionality of numpy array num_points. They are in dimension [NE][NS][[NM][NO], where oi gives the number of dispersion points at that offset. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for system test: test_korzhnev_2005_all_data. The masking for replacing values was wrong. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the cleaning of data points and replacing of values of out loop for model NS MMQ 2-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for structure cleaning and value replacing for model MMQ CR72. System test: test_korzhnev_2005_all_data revealed how this should be done properly. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for system test test_korzhnev_2005_all_data_disp_speed_bug. The precision is lowered, and now matches the original system test. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced index to numpy array from example [0][si][mi][oi] to [0, si, mi, oi]. Task #7807: Speed-up of dispersion models for clustered analysis.
- More replacing of numpy index. Task #7807: Speed-up of dispersion models for clustered analysis.
- Documentation fix, where a double bracket "[[" has been copied into all lib functions. Task #7807: Speed-up of dispersion models for clustered analysis.
- More fixes for numpy index in lib functions. Task #7807: Speed-up of dispersion models for clustered analysis.
- Restructured target function for NS MMQ 3-site to the new API structure of higher dimensional data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Reordered the lib function for NS MMQ 3-site to use higher dimensional data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Documentation fix for which dimensionality number of points have. Task #7807: Speed-up of dispersion models for clustered analysis.
- Documentation fix for the initial data structure of cpmg_frqs, spin_lock_nu1, r1. They were incorrect. Task #7807: Speed-up of dispersion models for clustered analysis.
- First attempt to implement target function for NS R1rho 2-site. But it does not work yet. Task #7807: Speed-up of dispersion models for clustered analysis.
- First attempt to implement lib function for NS R1rho 2-site. But it does not work yet. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fatal fix for calling inv_relax_time from relax_time variable. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removal of the temporary offset argument. Task #7807: Speed-up of dispersion models for clustered analysis.
- Documentation fix for the dimensionality of the input arrays. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented the target function for NS R1rho 3-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented the lib function for NS R1rho 3-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented target function for LM63 3-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented the lib function for LM63 3-site, for higher dimensional data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed the number of disp points in target function for LM63 3-site, since it is no longer used, but have been replaced with mask replacements. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented class function in target class, to return back_calc values as list of lists. This is the back and forth conversion between the data structures implemented when gathering the data, and the data send to the library function of higher dimensionality. Task #7807: Speed-up of dispersion models for clustered analysis.
- Used the new class function: get_back_calc(), to get the data in the right structures when interpolating for graphs. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed superfluous check, after the returned data is now in right structure. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made changes to the dir argument of system test Relax_disp.test_r1rho_kjaergaard. This is to prepare for: sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}and sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. This is also to test an expected bug, if R_{1}is not loaded. Task #7807: Speed-up of dispersion models for clustered analysis. - The relaxation dispersion target function can now be set up when the optional frqs_H argument is None. This allows the profiling scripts to run.
- More stability fixes for the relaxation dispersion target function initialisation. The target function can now be initialised when the r1 and chemical_shift arguments are None.
- Split the system test test_r1rho_kjaergaard into a setup function, and a test function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Renamed system test test_r1rho_kjaergaard to test_r1rho_kjaergaard_auto. This corresponds to the use of the automatic analysis method. Task #7807: Speed-up of dispersion models for clustered analysis.
- Split system test test_r1rho_kjaergaard into test_r1rho_kjaergaard_auto and test_r1rho_kjaergaard_man. This is to test use of the manual way to analyse. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified all of Troels' dispersion profiling scripts to work with older relax versions. This is in preparation for obtaining some powerful timing statistics. The calls to the r2eff_*() functions are unnecessary and are the only failure point in the scripts between the current code in the disp_spin_speed branch and trunk or older versions of relax. So these function calls have been eliminated.
- Implemented system test test_r1rho_kjaergaard_missing_r1, for safety check if R
_{1}data is not loaded. The system test passes, so target function is safe. Task #7807: Speed-up of dispersion models for clustered analysis. - Python 3 support for the dispersion profiling scripts. The xrange() builtin function does not exist in Python 3, so this is now aliased to range() which is the same thing.
- Replaced double or triple hash-tags "##" with single hash-tags "#". Task #7807: Speed-up of dispersion models for clustered analysis.
- Copyright fixes for all the models, where Troels E. Linnet have made changes to make them functional for higher dimensional data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Copyright fix for model TSMFK01. Sebastien Morin did not take part of implementing the TSMFK01 model. Task #7807: Speed-up of dispersion models for clustered analysis.
- Created a super script for profiling the relaxation dispersion models. This script will execute all of the current profiling scripts in the directory test_suite/shared_data/dispersion/profiling for both the current version of relax and any other specified version (current set to the 3.2.2 relax tag). It will run the scripts and relax versions interleaved N=10 times and extract the func_*() target function call profile timings. This interleaving makes the numbers much more consistent. Averages and standard deviations are then calculated, as well as the speed up between the two relax versions. The results are printed out in a format suitable for the relax release messages.
- Increased the number of iterations to 1000 in all of the profiling scripts. This is for better statistics in the disp_profile_all.py script, and makes the number consistent between the different models.
- Added a log file for comparing the speed of the disp_speed_branch to relax 3.2.2. This is from the disp_profile_all.py statistics generating script.
- Made the processor.return_object get the back_calc structure in the expected order. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fixed the ordering of the relax versions in the dispersion super profiling script disp_profile_all.py. This has also been fixed in the disp_spin_speed branch to relax 3.2.2 comparison log.
- Added a log file for comparing the speed of the disp_speed_branch to relax 3.2.1. This is from the disp_profile_all.py statistics generating script.
- Added a profiling script for the NS CPMG 2-site expanded dispersion model. The script was copied from that of the CR72 model, and it only needed to be changed in a few places. This is the first numeric model profiling script.
- Updated the profiling super script and log for the NS CPMG 2-site expanded model. This shows that the single spin calculation is 1.8 times faster, and the cluster of 100 11.7 times faster, when compared to relax 3.2.2.
- Modified all of the dispersion model profiling scripts. The single() function for timing the single spin target function speed has been modified to include a second outer loop over 100 'spins'. This means that the timing numbers are equivalent to the cluster timings, as both are then over 100 spins. This now allows not only relax version differences and model differences to be compared, but also the non-clustered and clustered analysis speeds.
- Added a script for profiling the NS CPMG 2-site 3D relaxation dispersion model. Again this only involved copying one of the other scripts and modifying a few variable and function names.
- Added the NS CPMG 2-site 3D model to the dispersion super profiling script. To handle the fact that this script has nr_iter set to 100 rather than 1000 (as otherwise it is too slow), a list of scaling factors has been created to scale all timing numbers to equivalent values.
- Added DPL94 profiling script. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified profiling script for TSMFK01, to use correct parameters k
_{AB}and R_{2A}^{0}. Or else, the lib functions is just calculating with zero? Task #7807: Speed-up of dispersion models for clustered analysis. - Changes to profiling script of NS CPMG 2-site expanded. The model does not have R
_{2A}^{0}and R_{2B}^{0}, but only R_{2}. Task #7807: Speed-up of dispersion models for clustered analysis. - Made changes to the profiling script of NS CPMG 2-site 3D. Need to use the full model, when r2a and r2b is specified. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changes to profiling script of NS CPMG 2-site expanded. The unpacking can be removed. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for the profiling script of NS CPMG 2-site 3D. The model should also be specified to full. Task #7807: Speed-up of dispersion models for clustered analysis.
- The disp_profile_all.py super script now prints out the current relax version information. This is so that the log files contain information about the repository revision and path.
- Copied profiling script of DPL94 to NS R1rho 2-site.
- Improved the final printout from the disp_profile_all.py dispersion model super profiling script.
- Added profiling script for NS R1rho 2-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- The disp_profile_all.py dispersion model super profiling script is now executable.
- Decreased all nr_iter values by 10 and added more dispersion models to the super profiling script. This is for the dispersion model profiling scripts in test_suite/shared_data/dispersion/profiling/, all controlled by the disp_profile_all.py super profiling script for generating statistics using all of the other profiling scripts. The number of iterations needed to be decreased as otherwise it would now take almost 1 day to generate the statistics table.
- Moved the parter conversion in LM63 3-site into the lib function. This cleans up the target api function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Copied profiling script for DPL94 to TAP03.
- Copied profiling script for DPL94 to TP02.
- Copied profiling script for DPL94 to MP05.
- Copied profiling script for DPL94 to M61.
- Modified profiling script for TAP03 to be used. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified profiling script for TP02, to be used. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified profiling script for MP05. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified profiling script for M61. This is the last one. Task #7807: Speed-up of dispersion models for clustered analysis.
- Expansion of the disp_profile_all.py dispersion model super profiling scripts. The newly added profiling scripts for models M61, TP02, TAP03, and MP05 are now included in the super script to generate statistics for all of these as well. The nr_iter variable has also been changed to match the other analytic models, so that the standard deviations are lowered and the statistics are better.
- Moved the parameter conversion of MMQ CR72 into lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the parameter conversions of k
_{AB}, k_{BA}and p_{B}into lib function of NS MMQ 2-site. Task #7807: Speed-up of dispersion models for clustered analysis. - Moved the parameter conversion from target function to lib function for NS R1rho 2-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Updated the dispersion model speed statistics for the disp_spin_speed branch vs. relax-3.2.2. This now includes the NS CPMG 2-site 3D, DPL94, and NS R1rho 2-site dispersion models. The timings for the single spin analyses are now comparable to the clustered analysis, as the equivalent of 100 single spins is being used. The final printout is also in a better format to present for the relax release messages. These new results show the insane 160x speed up of the DPL94 model.
- Alignment improvements for the final printout from the dispersion model super profiling script. The log file has been updated with what the new formatting will look like.
- Updated the model names in the dispersion model super profiling script. The CR72, B14 and NS CPMG 2-site 3D models are the full, slower versions rather than the faster models with R
_{2}^{0}= R_{2A}^{0}= R_{2B}^{0}. The log file has been updated to match. - Moved the parameter conversion for NS MMQ 3-site into lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Updated the dispersion model profiling comparison of the disp_spin_speed branch vs. relax-3.2.2. The M61, TP02, TAP03, and MP05 models are now included. The final printout has been manually updated to reflect the newest version of the disp_profile_all.py super profiling script.
- Moved the parameter conversion for NS R1rho 3-site into lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Copied profiling script for CR72, so there is now a normal and a full version.
- Copied profiling for B14 to normal and full model.
- Created a text file suitable for use as part of the relax release notes. This contains the statistically averaged profiling information of the speed of the dispersion models in the disp_spin_speed branch vs. relax-3.2.2. This file has been created so that it can be used as part of the release notes for the version of relax that contains the insane speed ups of this branch. This file will be updated as new models are profiled and if any more speed ups magically appear.
- Copied profiling script for NS CPMG 2-site 3D.
- Copied profiling script for NS CPMG 2-site star.
- Copied profiling script for No Rex.
- Modified profiling script for B14, to R
_{2A}^{0}=R_{2B}^{0}. Task #7807: Speed-up of dispersion models for clustered analysis. - Implemented profiling script for NS CPMG 2-site 3D. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented profiling script for NS CPMG 2-site star and star full. Task #7807: Speed-up of dispersion models for clustered analysis.
- Copied profiling script to be used for LM63.
- Copied profiling script to model IT99.
- Added profiling script for IT99. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented profiling script for LM63. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the "eta_scale = 2.0**(-3.0/2.0)" out of lib function for MMQ CR72, since this is only needs to be computed once. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for spaces aroung "=" outside functions. Task #7807: Speed-up of dispersion models for clustered analysis.
- Critical fix for wrong space inserted in NS MMQ 3-site MQ. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fixed the input for unit test of MMQ CR72. The number of input parameters has been lowered. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added additional math domain checking in B14. This is when v1c is less than 1.0. Task #7807: Speed-up of dispersion models for clustered analysis.
- Comment fixing, for explaining the masking and replacing when Δω is zero. Task #7807: Speed-up of dispersion models for clustered analysis.
- Copied profiling script to be used for profiling the use of higher dimensional data for the numpy eig function.
- Implemented the collection of the 3D exchange matrix, for rank [NE][NS][NM][NO][ND][7][7]. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented test, to see if 3D exchange matrices are the same. This can be tested while running system test test_hansen_cpmg_data_to_ns_cpmg_2site_3D. Task #7807: Speed-up of dispersion models for clustered analysis.
- Shifted the computation of Rexpo two loops up. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added intermediate step with for loops. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added another intermediate step. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added function to compute the matrix exponential for higher dimensional data of shape [NE][NS][NM][NO][ND][7][7]. This is done by using numpy.einsum, to make the dot product of the last two axis. Task #7807: Speed-up of dispersion models for clustered analysis.
- Inserted intermediate step, to check if the matrix propagator to evolve the magnetization is equal when done for lower dimensional data of shape [7][7] and higher dimensional data of shape [NE][NS][NM][NO][ND][7][7]. A short example is shown at the wiki: http://wiki.nmr-relax.com/Numpy_linalg#Ellipsis_broadcasting_in_numpy.einsum. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented double speed of model NS CPMG 2-site 3D. This is done by moving the costly calculation of the matrix exponential out of the for loops. The trick was to find a method to do dot product of higher dimensions. This was done with numpy.einsum, example at: http://wiki.nmr-relax.com/Numpy_linalg#Ellipsis_broadcasting_in_numpy.einsum. Example: dot_V_W = einsum('...ij,...jk', V, W_exp_diag) where V, and W_exp_diag has shape [NE][NS][NM][NO][ND][7][7]. The profiling script shows a 2X speed up.
- Made notation consistent for variables, using "_i" to clarify extracted data from matrix. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the calculation the evolution matrix out of for loops. The trick is that numpy.einsum allows for dot product of higher dimension: The essential evolution matrix; This is a dot product of the outer [7][7] matrix of the Rexpo_mat and r180x_mat matrices, which have the shape [NE][NS][NM][NO][ND][7][7]; This can be achieved by using numpy einsum, and where ellipsis notation will use the last axis.
- Implemented system test: test_cpmg_synthetic_b14_to_ns3d_cluster. This is to catch failures of the model, when data is clustered. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed unused variables in NS CPMG 2-site 3D, to clean up the code. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added the NS matrices, rr1rho_3d_rankN, to collect the multi dimensional 3D exchange matrix, of rank [NE][NS][NM][NO][ND][6][6]. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added a check in lib/dispersion/ns_r1hro_2site.py, to see if the newly created multidimensional ns matrix of rank NE][NS][NM][NO][ND][6][6], is equal to the previous [6][6] matrix. It is. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added the relax_time to collection of rr1rho_3d_rankN matrix collection. This is to pre-multiply all elements with the time. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added a check, that the pre- relax_time multiplied multidimensional array, equal the previous. It does, to the sum of 1.0e
^{-13}. Task #7807: Speed-up of dispersion models for clustered analysis. - Made the function use the new multidimensional R_mat matrix. System test: test_tp02_data_to_ns_r1rho_2site still passes. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix to the matrix_exponential_rankN, to return the exact exponential for any higher dimensional square matrix of shape [NE][NS][NM][NO][ND][X][X]. The fix was to the eye(X), to make the shape the same as the input shape. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the costly calculation of the matrix exponential out of for loops. It was the numpy.eig and numpy.inv which was draining power. This speeds up model NS R1rho 2-site, by a factor 4X.
- Made the returned multidimensional rr1rho_3d_rankN, be of float64 type. Task #7807: Speed-up of dispersion models for clustered analysis.
- Cleaned up the code of NS R1rho 2-site, and removed the matrix argument to the function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed the parsing of a matrix to the lib function of NS R1rho 2-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added the function "rcpmg_star_rankN" for the collection of the multidimensional relaxation matrix for model NS CPMG 2-site star. Task #7807: Speed-up of dispersion models for clustered analysis.
- Insert check, that the newly created multidimensional matrix is the same. They are, but only to the fifth digit. Task #7807: Speed-up of dispersion models for clustered analysis.
- Started using the newly created multidimensional matrix. test_hansen_cpmg_data_to_ns_cpmg_2site_star. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added the system test: test_cpmg_synthetic_b14_to_ns_star_cluster, to check for the model is still working after change. Task #7807: Speed-up of dispersion models for clustered analysis.
- Started using the newly cR2 variable, extracted from higher dimensional data. This should be okay, but system test test_hansen_cpmg_data_to_ns_cpmg_2site_star, now fails.
- Changes of values to system test test_hansen_cpmg_data_to_ns_cpmg_2site_star. The values are changed, since χ
^{2}is lower than before. Task #7807: Speed-up of dispersion models for clustered analysis. - Moved the costly finding of matrix exponential out of for loops for eR_tcp. Task #7807: Speed-up of dispersion models for clustered analysis.
- Rearranged the code, to properly show the nested matrix exponentials in dot functions. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the costly matrix_exponential of cR2 out of for loops. Task #7807: Speed-up of dispersion models for clustered analysis.
- Rearranged the dot code, for better view. Task #7807: Speed-up of dispersion models for clustered analysis.
- Cleaned up the code in model NS CPMG 2-site star. Task #7807: Speed-up of dispersion models for clustered analysis.
- Simplified model NS CPMG 2-site 3D. The expansion of matrices to higher dimensionality is not necessary. Task #7807: Speed-up of dispersion models for clustered analysis.
- Further cleaned up the code in NS CPMG 2-site star. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed input of matrix, Rr, Rex, RCS and R to model NS CPMG 2-site star. These matrices is now extracted from NS matrix function rcpmg_star_rankN. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented the collection of the multidimensional matrix m1 and m2 in model NS MMQ 2-site. Inserted also a check, that the newly computed matrix is equal. They are, to the 6 digit. Task #7807: Speed-up of dispersion models for clustered analysis.
- Started using the newly created multidimensional m1 and m2 matrices. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the costly calculation of matrix_exponential of M1 and M2 out of for loop, in model ns_mmq_2site_mq. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made the function matrix_exponential_rankN also find the exponential if the experiments indices are missing. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for an extra axis inserted in eye function, when dimensionality is only [NS][NM][NO][ND]. This also fixes the index in the lib function of ns_mmq_2site_mq. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented same functionality in mmq_2site_sq_dq_zq. Problem, following system test fails: test_korzhnev_2005_15n_dq_data, test_korzhnev_2005_15n_mq_data, test_korzhnev_2005_15n_sq_data, test_korzhnev_2005_1h_mq_data, test_korzhnev_2005_1h_sq_data, test_korzhnev_2005_all_data, test_korzhnev_2005_all_data_disp_speed_bug. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed grid search, and lowered number of iterations for system test: test_cpmg_synthetic_b14_to_ns3d_cluster, test_cpmg_synthetic_b14_to_ns_star_cluster. This is to speed them up, since they before took 30 seconds. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for ns_mmq_2site_mq. Variable was wrong called. There seems to be a serious problem more with MQ.
- Reinserted old code. This fixes: test_korzhnev_2005_15n_mq_data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Forcing the dtype to be complex64, instead of complex128. This solves a range of system tests. The one who fails now is: test_korzhnev_2005_15n_zq_data, test_korzhnev_2005_1h_mq_data, test_korzhnev_2005_1h_sq_data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Forces complex64 in ns_mmq_2site_sq_dq_zq instead complex128. This fixes system tests: test_korzhnev_2005_15n_zq_data,test_korzhnev_2005_1h_sq_data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Force complex64 in ns_mmq_2site_mq. This solves all system tests. Forcing to be complex64, does not seems like a long standing solution, since complex128 is possible. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for using the old matrix_exponential of m1. One: test_korzhnev_2005_15n_sq_data is still failing. That still uses the matrix_exponential_rankN. There seems to be a problem with matrix_exponential_rankN, when doing complex numbers. Maybe the dtype has to get fixed? Use it as a input argument? It must be the einsum. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added the "dtype" argument to function matrix_exponential_rankN. This is to force the conversion of dtype, if they are of other type. This can be conversion from complex128 to complex64. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix the bug: "M2_i = M1_mat", which was causing the problems getting system tests to pass. Removed the specifications of which dtype, the initial matrices are created. They can be converted later, with the specification of dtype to matrix_exponential_rankN(). All system tests now pass. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the Bloch-McConnell matrix for 2-site exchange into lib/dispersion/ns_matrices.py. This is for consistency with the other code. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the matrices for Bloch-McConnell from lib ns_mmq_2site, since they are now defined in ns_matrices.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the Bloch-McConnell matrix for 3-site exchange, into the lib/dispersion/ns_matrices.py. This is to standardize the code. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed m1 and m2 to be sent to lib function of NS MMQ 2-site, since they are now populated inside the lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented the Bloch-McConnell matrix for 3-site exchange, for multidimensional data. Task #7807: Speed-up of dispersion models for clustered analysis.
- Inserted a check, that the new higher dimensional m1 and m2 matrices are equal to before. They are, to the 5 digit. Task #7807: Speed-up of dispersion models for clustered analysis.
- Started using the newly created higher dimensional Bloch-McConnell matrix for 3-site exchange. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the calculation of the matrix exponential out of for loops for NS MMQ 3-site MQ. Task #7807: Speed-up of dispersion models for clustered analysis.
- Converted NS MMQ 3-site/SQ/DQ/ZQ to calculate the matrix exponential out of the for loops. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed the complex64 to be used as dtype in matrix exponential. Fix for missing "_i" in variable. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed m1 and m2 to be sent to target function of ns_mmq_3site_chi2. They are now populated inside the lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Documentation and input fix for NS MMQ 2-site. The m1 and m2 matrices are populated inside the lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Renamed some numerical matrices, to get consistency in naming. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented multidimensional NS R1rho 3-site exchange matrix. Task #7807: Speed-up of dispersion models for clustered analysis.
- Inserted check, that newly multi dimensional matrix is equal the old. It is, to the 13 digit. Task #7807: Speed-up of dispersion models for clustered analysis.
- Started using the newly multidimensional 3D exchange matrix. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved the calculation of the matrix exponential out of the for loops for NS R1rho 3-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed the parameter "matrix" to be send to lib function of NS R1rho 3-site, since it is now populated inside the lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved parameter conversion for NS R1rho 3-site inside lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Cleaned up the Dispersion class target function, for creation of matrices, which is now populated inside the lib functions instead. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed p
_{A}and p_{B}from the matrix population function rcpmg_star_rankN, since they are not used. Task #7807: Speed-up of dispersion models for clustered analysis. - Removed p
_{A}and p_{B}from the matrix population function rr1rho_3d_2site_rankN, since they are not used. Task #7807: Speed-up of dispersion models for clustered analysis. - Documentation fix for the dimensionality for model NS R1rho 2-site. The data is lined up to be of form [NE][NS][NM][NO][ND]. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed p
_{A}, p_{B}and p_{C}from the matrix population function rr1rho_3d_3site_rankN, since they are not used. Task #7807: Speed-up of dispersion models for clustered analysis. - Deleted the profiling of eig function profiling script. This was never implemented. Task #7807: Speed-up of dispersion models for clustered analysis.
- For all profiling scripts, added conversion to numpy array for CPMG frqs and spin_lock, since some models complained in 3.2.2, that they were of list types. Also fixed IT99 to only have 1 spin, since clustering is broken in 3.2.2. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified super profiling script, to allow input to script, where alternative version of relax is positioned. Collected the variables in a list of lists, for better overview. Added a print out comment to IT99, to remember the bug. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added comment field to super profiling script. Task #7807: Speed-up of dispersion models for clustered analysis.
- Math domain fix for NS CPMG 2-site expanded. This is when t108 or t112 is zero, in the multidimensional array, a division error occurs. The elements are first set to 1.0, to allow for computation. Then elements are later replaced with 1e
^{100}. Lastly, if the elements are not part of the "True" dispersion point structure, they are cleaned out. Task #7807: Speed-up of dispersion models for clustered analysis. - Precision lowering of system test, test_korzhnev_2005_15n_sq_data and test_korzhnev_2005_1h_sq_data. The system tests does not fail on Linux 64-bit system, but only on Mac 32-bit system. This is due to floating error deviations. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added log files for super profiling against tags 3.2.1 and 3.2.2. Task #7807: Speed-up of dispersion models for clustered analysis.
- Copied lib.linear_algebra.matrix_exponential to lib.dispersion.matrix_exponential. The matrix exponential of higher dimensional data is only used in the dispersion part of relax.
- Added to __init__, the new lib.dispersion.matrix_exponential module. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added to unit_tests/_lib/_dispersion/__init__.py, the new unit test file: test_matrix_exponential.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added numpy array save files. They are the numpy array structures, which are send in from system test: Relax_disp.test_hansen_cpmg_data_to_ns_cpmg_2site_3D. These numpy array structures, are used in unit tests. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added unit test unit_tests/_lib/_dispersion/test_matrix_exponential.py to test the matrix exponential from higher dimensional data. lib.dispersion.matrix_exponential.matrix_exponential_rankN will match against lib.linear_algebra.matrix_exponential. Data which is used for comparison, comes from system test: Relax_disp.test_hansen_cpmg_data_to_ns_cpmg_2site_3D. Task #7807: Speed-up of dispersion models for clustered analysis.
- Renamed function to return data in unit test _lib/_dispersion/test_matrix_exponential.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix to lib/dispersion/matrix_exponential.py, since the svn copy command was used on non-updated version of the file. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added unit test for doing the matrix exponential for complex data. This test shows, that the dtype=complex64, should be removed from lib/dispersion/ns_mmq_2site.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added data for unit test for the testing of the matrix_exponential_rankN. Task #7807: Speed-up of dispersion models for clustered analysis.
- Expanded the dispersion profiling master script to handle any two relax versions. To compare two relax versions, for example 3.2.2 to 3.2.1, either the path1 and path2 variables or two command line arguments can be supplied. The first path should be for the newest version. This will allow for comparing the speed differences between multiple relax versions in the future.
- Split matrix_exponential_rankN into matrix_exponential_rank_NE_NS_NM_NO_ND_x_x and matrix_exponential_rank_NS_NM_NO_ND_x_x. Task #7807: Speed-up of dispersion models for clustered analysis.
- Moved numerical solution matrices into the corresponding lib function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Copied profiling scripts, to be used for 3-site models and MMQ models.
- Implemented profiling script for LM63 3-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Improved the relax version printouts for the dispersion model master profiling script. This now reports both relax versions.
- Removed a tonne of unused imports from the dispersion model profiling scripts. This is to allow most of the scripts to run on the relax 3.1.x versions, as well as to clean up the scripts. The unused imports were found using the command: pylint test_suite/shared_data/dispersion/profiling/*.py --disable=all --enable=unused-import.
- Added a relaxation dispersion model profiling log file for relax version 3.2.1 vs. 3.2.0. This is the output from the dispersion model profiling master script. It shows a 2.2 times increase in speed for the B14 and B14 full models, with all other models remaining at the same speed. This matches the changes for relax 3.2.1 (https://gna.org/forum/forum.php?forum_id=2462), the main feature of which is a major bugfix for the B14 models.
- The 'relax -v' command is now used for the dispersion model profiling script initial printout. This is to show the two different relax versions being compared.
- Modifications to the dispersion model profiling master script. The info.print_sys_info() function of the current relax version is being called at the start to show all information about the current system. This is useful to know the speed of the machine, the OS, the Python version and numpy version. The numpy version is important as future versions might optimise certain functions that are currently very slow, hence that could be a cause of model speed differences. In addition, the path variables path1 and path2 have been renamed to path_new and path_old to make it clearer which is which. And the individual profiling scripts are no longer copied to the base directory of the relax versions being compared, and are run in place.
- Added a relaxation dispersion model profiling log file for relax version 3.2.2 vs. 3.2.1. This is the output from the dispersion model profiling master script. It shows that the relax 3.2.2 release did not in fact feature "a large speed up of all analytic relaxation dispersion models" as described in the release notes at https://gna.org/forum/forum.php?forum_id=2465. For the CPMG models there is a 1 to 2 times increase in speed. But for the R
_{1ρ}models, there is a 1 to 2 times decrease in speed. - Added a relaxation dispersion model profiling log file for relax version 3.2.0 vs. 3.1.7. This is the output from the dispersion model profiling master script. It shows that there are no speed differences.
- Added a relaxation dispersion model profiling log file for relax version 3.1.7 vs. 3.1.6. This is the output from the dispersion model profiling master script. It shows that there are no speed differences.
- Modified profiling script for NS R1rho 3-site, to be functional. Task #7807: Speed-up of dispersion models for clustered analysis.
- Modified profiling script for NS R1rho 3-site linear to be functional. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added a relaxation dispersion model profiling log file for relax version 3.1.3 vs. 3.1.2 vs. 3.1.1. This is the output from the dispersion model profiling master script. It shows that there are no major speed differences between these relax versions.
- Added the system information printout to the dispersion model profiling master script output. This is for the log files comparing one version of relax to the previous version.
- Added profiling script for model MMQ CR72, Task #7807: Speed-up of dispersion models for clustered analysis.
- Fix for the replacement value for invalid values in model MMQ CR72. The value was set to use R
_{2}^{0}, but should instead be 1e^{100}. Task #7807: Speed-up of dispersion models for clustered analysis. - Copied profiling script from MMQ CR72, to NS MMQ 2-site and 3-site.
- Copied profiling script to NS MMQ 3-site linear.
- Implemented profiling script for NS MMQ 2-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented profiling script for NS MMQ 3-site and 3-site linear. Task #7807: Speed-up of dispersion models for clustered analysis.
- Speeded up model NS CPMG 2-site star, by moving the forming of the propagator matrix out of the for loops, and preform it. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added a relaxation dispersion model profiling log file for relax version 3.1.4 vs. 3.1.3. This is the output from the dispersion model profiling master script. It shows that there are no speed differences.
- Speeded up NS MMQ 2-site, by moving the forming of evolution matrix out of the for loops, and preform it. Task #7807: Speed-up of dispersion models for clustered analysis.
- Speeded up NS MMQ 3-site, by moving the forming of evolution matrix out of the for loops, and preform it. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added a relaxation dispersion model profiling log file for relax version 3.1.5 vs. 3.1.4. This is the output from the dispersion model profiling master script. It shows that there are no speed differences.
- Speeded up NS R1rho 2-site, by preforming the evolution matrices, and the M0 matrix in the init part of the target function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Speeded up NS R1rho 3-site, by preforming the evolution matrices, and the M0 matrix in the init part of the target function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Expanded the dispersion model profiling master script to cover all the new profiling scripts. This includes all 3-site and MMQ models. The list is now complete and covers all models. The only model not included in M61 skew which has redundant parameters and is not optimisable anyway.
- Added a relaxation dispersion model profiling log file for relax version 3.1.6 vs. 3.1.5. This is the output from the dispersion model profiling master script. It shows that there are almost no speed differences, except for a slight decrease in speed in the CR72 full model for single spins.
- Split system test test_tp02_data_to_ns_r1rho_2site into a setup and test part. Task #7807: Speed-up of dispersion models for clustered analysis.
- Implemented a clustered version of system test test_tp02_data_to_ns_r1rho_2site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Inserted an extremely interesting development in NS R1rho 2-site. If one do a transpose of M0, one can calculate all the matrix evolutions in the start via numpy einsum. Since M0 is in higher a dimensions, one should not do a numpy transpose, but swap/roll the outer M0 6x1 axis. Task #7807: Speed-up of dispersion models for clustered analysis.
- Shortened the code dramatically for NS R1rho 2-site. It is possible to calculate all in "one" go, after having the transposed/rolled-back M0 magnetization. Task #7807: Speed-up of dispersion models for clustered analysis.
- Speeded up the code of NS R1rho 2-site. This was essential done to numpy einsum, and doing the dot operations in multiple dimensions. It was though necessary to realize, that to do the proper dot product operations, the outer two axis if M0 should be swapped, by rolling the outer axis one back. Task #7807: Speed-up of dispersion models for clustered analysis.
- Speeded up the code of NS R1rho 3-site. This was essential done to numpy einsum, and doing the dot operations in multiple dimensions. It was though necessary to realize, that to do the proper dot product operations, the outer two axis if M0 should be swapped, by rolling the outer axis one back. Task #7807: Speed-up of dispersion models for clustered analysis.
- For model NS CPMG 2-site 3D, the M0 matrix was preformed for higher dimensionality in init of target function. The transposes/rolled axis versions was also initiated. Task #7807: Speed-up of dispersion models for clustered analysis.
- Swapped the dot product position, when propagating the magnetisation in model NS CPMG 2-site 3D. This it to try to align to same method as in NS R1rho 2-site. Task #7807: Speed-up of dispersion models for clustered analysis.
- Lowered the looping in NS CPMG 2-site 3D, by preforming the initial dot product. Task #7807: Speed-up of dispersion models for clustered analysis.
- Speeded up NS CPMG 2-site 3D, by preforming the magnetisation. Task #7807: Speed-up of dispersion models for clustered analysis.
- Got rid of the inner evolution of the magnetization. If the looping over the number of CPMG elements is given by the index l, and the initial magnetization has been formed, then the number of times for propagation of magnetization is l = power_si_mi_di-1. If the magnetization matrix "Mint" has the index Mint_(i,k) and the evolution matrix has the index Evol_(k,j), i=1, k=7, j=7 then the dot product is given by: Sum_{k=1}^{k} Mint_(1,k) * Evol_(k,j) = D_(1, j). The numpy einsum formula for this would be: einsum('ik,kj -> ij', Mint, Evol). Following evolution will be: Sum_{k=1}^{k} D_(1, j) * Evol_(k,j) = Mint_(1,k) * Evol_(k,j) * Evol_(k,j). We can then realize, that the evolution matrix can be raised to the power l. Evol_P = Evol
^{l}. It will then be: einsum('ik,kj -> ij', Mint, Evol_P). Get which power to raise the matrix to. l = power_si_mi_di-1. Raise the square evolution matrix to the power l. evolution_matrix_T_pwer_i = matrix_power(evolution_matrix_T_i, l), Mint_T_i = dot(Mint_T_i, evolution_matrix_T_pwer_i) or Mint_T_i = einsum('ik,kj -> ij', Mint_T_i, evolution_matrix_T_pwer_i). Task #7807: Speed-up of dispersion models for clustered analysis. - Tried to implement using lib.linear_algebra.matrix_power.square_matrix_power instead of matrix_power from numpy in NS CPMG 2-site 3D. Strangely, then system test: test_hansen_cpmg_data_to_ns_cpmg_2site_3D_full starts to fail. Task #7807: Speed-up of dispersion models for clustered analysis.
- Changes to unit test of NS CPMG 2-site 3D. This is after the new initiated M0 matrix in init of target function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Double speed in NS CPMG 2-site star, after using numpy.linalg.matrix_power instead of the lib version in relax. Task #7807: Speed-up of dispersion models for clustered analysis.
- Triple speed in NS MMQ 2-site, after using numpy.linalg.matrix_power instead of the lib version in relax. Task #7807: Speed-up of dispersion models for clustered analysis.
- Small fix for making sure that power is a integer in NS MMQ 2-site. Following system tests was failing: Relax_disp.test_korzhnev_2005_15n_dq_data, Relax_disp.test_korzhnev_2005_15n_sq_data, Relax_disp.test_korzhnev_2005_15n_zq_data, Relax_disp.test_korzhnev_2005_1h_sq_data, Relax_disp.test_korzhnev_2005_all_data, Relax_disp.test_korzhnev_2005_all_data_disp_speed_bug. They should already be integers, but is now solved. Task #7807: Speed-up of dispersion models for clustered analysis.
- Comment and spell fixing in NS CPMG 2-site 3D. Task #7807: Speed-up of dispersion models for clustered analysis.
- Triple speed in NS MMQ 3-site, after using numpy.linalg.matrix_power instead of the lib version in relax. Task #7807: Speed-up of dispersion models for clustered analysis.
- Updated the dispersion model profiling comparison of the disp_spin_speed branch vs. relax-3.2.2. This now includes all dispersion models. This shows the large speed increases in the numeric and MMQ models recently obtained. Note that something went wrong with the NS CPMG 2-site 3D full model for the clustered analysis, most times were around 24 seconds except for the first which was strangely 292 seconds.
- Updated the relaxation dispersion model profiling log file for relax version 3.2.2 vs. 3.2.1. This adds the MMQ and 3-site models to the log file. The new information shows that there was a 4.2 times speed up for the MMQ CR72 model between these two relax versions, both for single spins and clustered spins, a much greater improvement than any other of the models.
- Removed the now redundant disp_profile_all_3.2.2.table.txt dispersion model profiling table. As the dispersion model profiling master script now covers all dispersion models, the output from this script produces this table exactly. Therefore the end of the log files saved from running this script contains this table.
- Initiated lengthy profiling script, that shows that doing square numpy matrix_power on strided data, can speed up the calculation by factor 1.5. The profiling script can quickly be turned into a unit test, and includes small helper functions to calculate how to stride through the data. Task #7807: Speed-up of dispersion models for clustered analysis.
- First try to implement function that will calculate the matrix exponential by striding through data. Interestingly, it does not work. These system tests will fail: test_hansen_cpmg_data_to_ns_cpmg_2site_3D, test_hansen_cpmg_data_to_ns_cpmg_2site_3D_full. Task #7807: Speed-up of dispersion models for clustered analysis.
- Added matrix_power to the init file in lib/dispersion. Task #7807: Speed-up of dispersion models for clustered analysis.
- Deleted the printout in dep_check. The printouts are only used for the essential packages before calling sys.exit(). Task #7807: Speed-up of dispersion models for clustered analysis.
- Added the missing "self.num_exp" to target function. Testing on older system, this was failing the system test. It is a wonder how these lines in __init__ could be performed without this.
- Fix for unit test passing on old numpy systems. The error was: ValueError: setting an array element with a sequence. Task #7807: Speed-up of dispersion models for clustered analysis.
- Expanded the dispersion target function class documentation. The NE, NS, NM, NO, and ND notation is now explained.
- Added Ti and NT to the dispersion target function class documentation.
- Slight speed up of the B14 and B14 full dispersion models by minimising repetitive maths.
- Initial try to write up a 2x2 matrix by closed form. Task #7807: Speed-up of dispersion models for clustered analysis.
- Made the validation check in profiling of matrix_power check all values. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced all self.spins with self.NS in target function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced all self.num_exp with self.NE in target function. Task #7807: Speed-up of dispersion models for clustered analysis.
- Replaced all self.num_frq with self.NM in target function. Task #7807: Speed-up of dispersion models for clustered analysis.
- A very small speed up to the CR72 dispersion models by minimising repetitive maths operations. The k
_{BA}and k_{AB}rates are used to simplify the Psi calculation, dropping from 3 to 2 multiplications and removing a squaring operation. The Dpos and Dneg value calculations have been simplified to drop one multiplication operation. And the calculation of eta_scale / cpmg_frqs now only occurs once rather than twice. - Removal of a tonne of unused imports in the lib.dispersion package. These were identified using the command "pylint * --disable=all --enable=unused-import".
- A very small speed up to the MMQ CR72 dispersion model by minimising repetitive maths operations. This matches the recent change for the CR72 model, though the Psi calculation was already using the fast form.
- Created a master profiling script for comparing the speed between different dispersion models. This is similar to the disp_profile_all.py script except it only operates on a single relax version. The output is then simply the timings, with statistics, of the calculation time for 100 function calls for 100 spins (either 10,000 function calls for single spins or 100 function calls for the cluster of 100 spins). The output of the script for the current disp_spin_speed branch code has also been added.
- Critical fix for the recalculation of tau cpmg, when plotting for numerical models. The interpolated dispersion points with tau_cpmg was calculated with frq, instead of cpmg_frq. Task #7807: Speed-up of dispersion models for clustered analysis.
- The new dispersion model profiling master script now includes links to the relax wiki. The models are no longer presented by name but rather by the relax wiki links for each model (see Category:Relaxation dispersion analysis for all these links). This is to improve the Google rank of the relax wiki, as these links may appear in a number of locations.
- Removal of many unused imports in the disp_spin_speed 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.
- Code validation of lib/dispersion/b14.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/cr72.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/dpl94.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/lm63_3site.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/lm63.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/m61b.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/m61.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/matrix_exponential. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/mp05.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/ns_cpmg_2site_expanded.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/ns_cpmg_2site_star.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/ns_mmq_2site.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/ns_mmq_3site.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/ns_r1rho_2site.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/ns_r1rho_3site.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/tap03.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/tp02.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of lib/dispersion/two_point.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Code validation of target_functions/relax_disp.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- For model NS MMQ 3-site, moved the parameter conversion of Δω
_{AB}from target function to lib function. Task #7807: Speed-up of dispersion models for clustered analysis. - Removed chi sum initialisation in func_ns_mmq_2site() as this is not used. Task #7807: Speed-up of dispersion models for clustered analysis.
- Documentation fix for the get_back_calc() function in target_function/relax_disp.py. Task #7807: Speed-up of dispersion models for clustered analysis.
- Removed unnecessary repetitive calculation of k
_{ex}^{2}in model DPL94. Task #7807: Speed-up of dispersion models for clustered analysis. - API documentation fixes, where a "\" is the last character on the line. There should be a space " ", ending this character. Task #7807: Speed-up of dispersion models for clustered analysis.
- Updated the minfx version number to 1.0.9 in the release checklist document. This as of yet unreleased version contains an important fix for parallelised grid searches when the number of increments is set to one (i.e. a preset parameter).
- Fix for the _prompt.test_align_tensor.Test_align_tensor.test_init_argfail_params unit test. As the alignment tensor can now be initialised as None, the None value can be accepted and a different RelaxError is raised when the params argument is incorrectly supplied.
- Added a new set of icons for use with the minimisation user functions. These are of the Rosenbrock function and are much better suited for small icons than the current OpenDX 3D isosurface plots. The matplotlib figure originates from public domain code at http://commons.wikimedia.org/wiki/File:Rosenbrock_function.svg.
- Redesign of the optimisation user functions calculate, grid_search, and minimise. In preparation for expanding the number of optimisation user functions, these three current user functions have been shifted into the new minimise user function class. The calc user function is now accessed as minimise.calculate. The grid search as minimise.grid_search. And minimisation is via the minimise.execute user function. The icon used for the new user function class is the Rosenbrock function or the banana optimisation problem. As this is such a radical change, a huge number of changes in the relax source code, the sample scripts, the user manual, and the test suite were required.
- Created the new minimise.grid_zoom user function. This allows the grid zoom level to be set. The value is stored in the current data pipe and will be used later by the minimise.grid_search user function.
- The minimise.grid_zoom user function now uses the zoom-in Oxygen icon.
- Created the Relax_fit.test_zooming_grid_search system test. This will be used to test the implementation of the zooming grid search. The relaxation curve-fitting analysis should be one of the fastest for testing this.
- Added the print_model_title() method to the specific analysis base API class. This will be used to format and print out the information returned by the model_info() API method.
- Implemented the print_model_title() specific analysis API method for the dispersion analysis.
- Modified the specific analysis API _model_loop_spin() common method. This now additionally returns the spin ID string to allow the corresponding spin container to be identified.
- Implemented the specific analysis API common method _print_model_title_spin(). This is for the corresponding _model_loop_spin() method. It can be aliased in the specific analyses to provide the print_model_title() API method.
- Aliased the _print_model_title_spin() specific analysis API common method in a few analyses. This provides the print_model_title() API method for the J(ω) mapping, consistency testing, and relaxation curve fitting analyses.
- Updated all the specific analysis methods affected by the _model_info_spin() API method change. This is for the change whereby the common API method now returns the spin ID string as well.
- Implemented get_param_names() and get_param_values() for the relaxation curve-fitting analysis. These are part of the specific analysis API.
- Created the specific analysis API return_parameter_object() function. This is used by the non-specific analysis code to obtain the parameter object (a singleton object). It will allow for more direct access to the parameter information.
- Created the parameter object infrastructure for adding the grid search lower and upper bounds. The _add() method now accepts the grid_lower and grid_upper keyword arguments, which can be either values or functions. These are then stored in the _grid_lower and _grid_upper class dictionaries. The public methods grid_lower() and grid_upper() have been added to return the value corresponding to the given parameter.
- Modified the specific analysis parameter object grid_lower() and grid_upper() methods. These now accept the model information from the model_loop() API method and send that into an grid lower and upper functions. These functions will require the information to pull out the correct spin, spin cluster, or other information from the current data pipe to determine what the bounds should be.
- Implemented infrastructure in the grid_search user function in preparation for the zooming grid. The grid search backend now calls the new grid_bounds() function. This takes the lower and upper bounds as arguments, uses the specific API to determine the per-model parameter grid search bounds, and then returns a per model list of lower and upper bounds. The specific API get_param_names() and get_param_values() are called to obtain the current model parameter names and values, and then the parameter names and model info are used in the new parameter object grid_lower() and grid_upper() methods to obtain the bounds. This shifts all of the grid search bounds logic out of the specific analyses and into the grid search backend, so it should allow the specific analysis code to be simplified.
- More modifications of the minimise.grid_search user function backend. The grid_bounds() function has been renamed to grid_setup(), and it now accepts and processes the inc user function argument. The error checking code of the relaxation curve-fitting grid_search_setup() optimisation function has been shifted into this analysis independent grid_setup() function to shift the minimise.grid_search user function error checking out of the specific analyses. The function now scales the parameter bounds, using the yet-to-be implemented scaling() method of the parameter object. And the grid search increments are converted into a per-model list of lists.
- Created the parameter object infrastructure for registering parameter scalings. The _add() method now accepts the scaling keyword argument, which can be either a value or function. This is then stored in the _scaling dictionary. The public method scaling() has been added to return the scaling factor corresponding to the given parameter.
- Modified the analysis specific API optimisation method. The base calculate(), grid_search() and minimise() methods now all accept the scaling_matrix argument, and the minimise() scaling argument has been removed. This scaling_matrix argument should be a per-model list of scaling matrices. To handle the change, the pipe_control.minimise.assemble_scaling_matrix() function has been created. This uses the new parameter object scaling values to create the list of scaling matrices. This will in the end replace all of the analysis specific assemble_scaling_matrix() functions and simplify their optimisation code paths.
- Changed the order of operations in the minimisation user function backends. The specific analysis API overfit_deselect() method needs to be called before any grid bounds, increments, or the scaling matrices are assembled. This is for the cases when the grid bounds or scaling factors are functions rather than values.
- Converted the relaxation curve-fitting analysis to the new grid bounds and scaling factor design. The parameter object now registers the grid bounds and scaling factors for all of the curve-fitting parameters. This includes three functions i_scaling(), i0() and iinf() in the specific_analyses.relax_fit.parameter_object module for calculating some of these values. The specific_analyses.relax_fit.parameters.assemble_scaling_matrix() function has been deleted as this is now provided by the upstream code in pipe_control.minimise. And the API methods grid_search() and minimise() has been modified to accept the list of scaling matrices. As the grid bounds and increments are now handled by the upstream pipe_control.minimise.grid_setup() function, the specific_analyses.relax_fit.optimisation.grid_search_setup() function was redundant and was deleted.
- Created the consistency testing specific API method get_param_names(). This is now required for the minimise.calculate user function, specifically for the analysis independent assemble_scaling_matrix() function. The get_param_names() method simply returns the fixed list of parameter names.
- Standardisation of the specific analysis API with respect to the model_loop() and base_data_loop(). The model information arguments for the data returned by model_loop(), and the data arguments for the data arguments for the data returned by base_data_loop() have been standardised throughout the API.
- Epydoc parameter order rearrangement in the specific analysis API base class.
- Updated the specific analysis API common methods for the recent model_info argument changes.
- Updated all of the specific API calculate() methods to accept the scaling_matrix argument. The list of per-model scaling matrices is now created independently of the analysis type by the pipe_control.minimise methods for the minimise.calculate, minimise.grid_search and minimise.execute user functions and sent into the specific analysis backend.
- Updated all of the specific API grid_search() methods to accept the scaling_matrix argument. The list of per-model scaling matrices is now created independently of the analysis type by the pipe_control.minimise methods for the minimise.calculate, minimise.grid_search and minimise.execute user functions and sent into the specific analysis backend. The argument is also passed into the minimise() API method from the grid_search() method when that is used.
- Updated all of the specific API minimise() methods to accept the scaling_matrix argument. The list of per-model scaling matrices is now created independently of the analysis type by the pipe_control.minimise methods for the minimise.calculate, minimise.grid_search and minimise.execute user functions and sent into the specific analysis backend.
- Fix for the Monte Carlo simulations for the model_info argument changes in the specific API.
- Fixes for the consistency testing and J(ω) mapping calculate() methods. This is for the changes to the data_init() specific analysis API method.
- More fixes for the Monte Carlo simulations for the model_info argument changes in the specific API.
- Updated all of the data_init() specific API calls where the spin ID is expected.
- Fixes for the _data_init_spin() specific API common method. The data returned from _base_data_loop_spin() is just the spin ID, the spin container is not included.
- Updated the eliminate user function backend to work with the model_info argument changes in the specific API.
- The new pipe_control.minimise module functions can now handle models with no parameters. The new assemble_scaling_matrix() and grid_setup() functions will now handle models with no parameters, as this is required for the relaxation dispersion analysis.
- More fixes for the eliminate user function backend. This is for the model_info argument changes in the specific API.
- Fixes for the grid search backend for a recent breakage and expansion of its capabilities. The user supplied lower and upper bounds for the grid search were no longer being scaled via the scaling matrix. In addition, the code has been refactored to be simpler and more flexible. The user can now supply just the lower or just the upper bounds and the grid search will work.
- The grid search setup function now prints out the grid search bounds to be used. This is in the pipe_control.minimise.grid_setup() function, hence it is analysis independent. This is useful feedback for the user to know what the grid search is doing. And it will be even more useful for the zooming grid search to understand what is happening.
- The grid search setup printout now also included the number of increments for each parameter.
- Modified the new print_model_title() specific analysis API method. This now accepts the prefix argument for creating different titles independently of the specific analysis.
- The grid search setup function now uses the prefix argument to the print_model_title() API function. This is simply set to 'Grid search setup:'.
- The relaxation dispersion API now uses the MODEL_R2EFF variable for identifying the R2eff model.
- Changes to the minimise.grid_search user function frontend. The Boolean constraints argument has been shifted to the end, and empty lines have been removed.
- Epydoc docstring fixes for the keyword arguments of the pipe_control.minimise module.
- Shifted the constraints Boolean argument to the end of the grid_search() function argument list.
- Major change to the grid_search user function. The minimise.grid_search user function now accepts the skip_preset flag. When True, the grid search will skip any parameters with a preset value. This allows the user to set parameters via the value.set user function and then have these parameters skipped in the grid search. The new skip_preset argument is passed into the pipe_control.minimise.grid_setup() function in the backend. This then sets both the grid lower and upper bounds to the preset parameter value and sets the number of increments to 1 for that parameter so that it is essentially skipped in the grid search.
- Small change to the table printed out during the minimise.grid_search setup.
- Fix for the skipping of preset parameters in the grid search. Dictionary and list type parameters are now handled correctly.
- Converted the relaxation dispersion analysis to the new grid bounds and scaling factor design. The parameter object now registers the grid bounds and scaling factors for all of the dispersion parameters. This includes the functions dw_lower(), dwH_lower(), pA_lower() and i0_upper() in the specific_analyses.relax_disp.parameter_object module for calculating some of these values. The specific_analyses.relax_disp.parameters.assemble_scaling_matrix() function has been deleted as this is now provided by the upstream code in pipe_control.minimise. And the API methods grid_search() and minimise() has been modified to accept the list of scaling matrices. As the grid bounds and increments are now handled by the upstream pipe_control.minimise.grid_setup() function, the specific_analyses.relax_disp.optimisation.grid_search_setup() function was redundant and was deleted. The specific_analyses.relax_disp.parameters.get_param_names() function was also modified with the full argument added, to allow either the base parameter names or an augmented form with the dictionary key for presenting to the user to be returned. Importantly to allow the changes to be operational, the model_loop() API method was redesigned so that, for the R2eff base model, the individual spins rather than spin clusters will be looped over. This allows the specific_analyses.relax_disp.optimisation.minimise_r2eff() function to continue to operate correctly.
- Implemented the J(ω) mapping analysis get_param_names() API method. This simply returns the hardcoded list of 3 parameters of the model, and allows the minimise.calculate user function to operate.
- Updated the _print_model_title_spin() specific API common method. This now accepts the prefix argument and adds this to the title.
- The minimise.grid_search user function can now properly handle preset values of NaN. This occurs when the parameter vector contains values of None due to the parameter not being set and then the Python list being converted to a numpy array. The value of NaN is now caught and the parameter is no longer identified as being preset.
- Fixes for the relaxation curve-fitting grid search. The parameters which are not set are no longer defaulting to 0.0. This means that the parameter vector will sometimes contain NaN values, but this is important for the correct operation of the new minimise.grid_search user function backend.
- Updated the NOE analysis to handle the changes for the minimise.calculate user function. This now requires the model_loop() and get_param_names() API methods to be implemented. The first is provided by the API common _model_loop_spin() method and the second simply returns a list of the single 'noe' parameter.
- Created the _print_model_title_global() specific analysis API method. This is to be paired with the _model_loop_single_global() API method and it simply prints out the prefix as the title.
- Created the specific analysis parameter object _add_align_tensor() method. When called by a specific analysis, this will add the [Axx, Ayy, Axy, Axz, Ayz] parameters to the corresponding parameter object.
- Deleted the lib.optimisation module. The checks in the single test_grid_ops() function are implemented in the pipe_control.minimise.grid_setup() function and are now redundant.
- Removed the import of the now deleted lib.optimisation module from the model-free analysis.
- Converted the N-state model analysis to the new grid bounds and scaling factor design. The parameter object now registers the grid bounds and scaling factors for all of the N-state model parameters. The specific_analyses.n_state_model.parameters.assemble_scaling_matrix() function has been deleted as this is now provided by the upstream code in pipe_control.minimise. And the API methods grid_search() and minimise() has been modified to accept the list of scaling matrices. In addition, all of the lower bounds defined in the grid_search() API method have been deleted as this is now in the parameter object. The new API function print_model_title() has been aliased from _print_model_title_global(). And the get_param_names() and get_param_values() API methods have been implemented.
- The grid search upper and lower bound functions now must accept the incs argument. For a few analyses, the number of grid search increments are used to remove the end point of the grid, to remove duplicate points due to the circular nature of angles. Therefore the parameter object grid_lower() and grid_upper() methods now send the grid increment number for each parameter into all grid bound determining functions. The relaxation dispersion and curve-fitting analyses have been updated for the change.
- Converted the frame order analysis to the new grid bounds and scaling factor design. The parameter object now registers the grid bounds and scaling factors for all of the dispersion parameters. This includes the functions angle_upper_excluding_bound(), axis_alpha_upper(), cone_angle_lower(), cone_angle_upper(), pivot_grid_bound(), pivot_x_lower(), pivot_x_upper(), pivot_y_lower(), pivot_y_upper(), pivot_z_lower(), and pivot_z_upper() in the specific_analyses.frame_order.parameter_object module for calculating some of these values. The specific_analyses.frame_order.parameters.assemble_scaling_matrix() function has been deleted as this is now provided by the upstream code in pipe_control.minimise. And the API methods grid_search() and minimise() has been modified to accept the list of scaling matrices. As the grid bounds and increments are now handled by the upstream pipe_control.minimise.grid_setup() function, the setup and error checking code in the grid_search() API method was redundant and was deleted.
- Modified all calls to the parameter object _add() base class method. These are now all spread across multiple lines, with each argument on a separate line. This is for easier maintenance of the specific analysis parameters, as the code is now much cleaner and argument changes will only have diffs for that argument. It is also visually easier to see all the settings for each parameter.
- Fix for the grid search setup printout when parameters are preset.
- Changes to the diffusion tensor initialisation in the model-free auto-analysis. The values of the tensor are now initialised to None. This is to allow for the new grid search preset flag which defaults to True, setting the values to None indicates that a grid search should be performed.
- The diffusion_tensor.init user function can now set initial tensor parameter values of None. This is to allow for the new grid search preset flag. Therefore allowing the values to be None allows for a grid search to be performed by default.
- Created two new model-free system tests. These are Mf.test_m0_grid_with_grid_search and Mf.test_m0_grid_vs_m1_with_grid_search. Their aim is to better test the grid search in a model-free analysis when parameters are preset.
- Converted the model-free analysis to the new grid bounds and scaling factor design. The parameter object now registers the grid bounds and scaling factors for all of the model-free parameters. This includes the functions rex_scaling() and rex_upper() in the specific_analyses.model_free.parameter_object module for calculating some of these values. The base parameter object has also been updated as that is where the diffusion parameters are defined. Here the da_lower() and da_upper() have been defined to handle the different Da value constraints. The specific_analyses.model_free.parameters.assemble_scaling_matrix() function has been deleted as this is now provided by the upstream code in pipe_control.minimise. And the API methods grid_search() and minimise() has been modified to accept the list of scaling matrices. As the grid bounds and increments are now handled by the upstream pipe_control.minimise.grid_setup() function, the grid_search_config(), grid_search_diff_bounds() and grid_search_spin_bounds() functions in the specific_analyses.model_free.optimisation module were redundant and were deleted. The new API function print_model_title() has been implemented to handle the grid search setup printouts.
- Modified the pipe_control.minimise.grid_setup() function for when no parameters are present. For the current version of minfx to function correctly (1.0.8), the lower, upper and inc values should be set to [] rather than None.
- Fix for the lib.arg_check.is_num_or_num_tuple(). When the can_be_none flag is set to True, the tuple of None values is now considered valid. This enable the diffusion_tensor.init user function to accept the spheroid tensor values of (None, None, None, None), and the ellipsoid tensor values as a tuple of 6 None.
- Fix for the _prompt.test_diffusion_tensor.Test_diffusion_tensor.test_init_argfail_params unit test. As the diffusion tensor can now be initialised as None, the None value can be accepted and a different RelaxError is raised when the params argument is incorrectly supplied.
- Modified the behaviour of the parameter object units() method. If the unit is set to the default of None, this method will now return an empty string instead of None.
- The rx parameter of the relaxation curve-fitting analysis now has 'rad.s^-1' units defined.
- Implemented the zooming grid search. If the zoom level is set to any value other than 0, then the grid width will be divided by 2
^{zoom_level}and centred at the current parameter values. If the new grid is outside of the bounds of the original grid, the entire grid will be translated so that it lies entirely within the original. - Modified the zooming grid search algorithm. If the zoom level is negative, hence the grid will be larger than the original, the checks that the grid is within the original are no longer active.
- Changed the minimise.grid_zoom user function. The zoom level can now be any floating point number or integer, including negative values. The user function docstring has been significantly expanded to explain the entire zooming grid search concept.
- Alphabetical ordering of the minimisation user functions in the user_functions.minimisation module.
- Large expansion of the minimise.grid_search user function documentation. The previous documentation was essentially non-existent.
- Expanded the minimise.grid_zoom user function documentation. A few sentences about the limitations of the algorithm have been added.
- Completed the Relax_fit.test_zooming_grid_search system test. Now only a single spin is optimised. The zooming levels increase in integer increments from 0 to 50 so that the final zoomed grid is insanely small (as the curve-fitting C modules are incredibly fast, this test is nevertheless relatively quick). The final zooming grid search parameter values are checked to see if they are the same as those optimised in the Relax_fit.test_curve_fitting_height system test to demonstrate the success of the algorithm.
- Modified the grid search upper bounds functions for the relaxation curve-fitting. This is for both the exponential relaxation curve-fitting analysis and the same fitting in the dispersion analysis. The intensity values are doubled and then rounded to the next order. This ensures that I
_{0}and I_{∞}will be within the grid bounds. Hence the zooming grid search can be used for these curves. - Expanded the documentation for the minimise.calculate user function. This now explains the dual operations of the user function.
- Fixes for some relaxation dispersion system tests not converted to the new optimisation user functions. Minimisation is now via the minimise.execute user function, which used to be the minimise user function.
- Added a 128x128 pixel version of the zoom-in Oxygen icon. This icon size is not available in the repository located at svn://anonsvn.kde.org/home/kde/trunk/kdesupport/oxygen-icons. Therefore the scalable/actions/small/48x48/zoom-in.svgz file was copied and then exported into a 128x128 PNG, and finally converted to a Gzipped EPS file for the relax manual.
- The frame order grid search bound functions can now handle increment values of None or 1. These cases are now caught and the full lower or upper bound is now returned.
- More even spacing for the frame order grid search. This is for the parameters which exclude end points in the grid search, as these excluded points do not decrease the number of increments searched over.
- Even more even spacing for the frame order grid search. This is for the parameters which exclude end points in the grid search, as these excluded points do not decrease the number of increments searched over. This fixes the algorithm for all of the bounds.
- Improved the logic for skipping parameters in the grid search. The logic is also fully explained in the user function documentation.
- Removal of all unused imports. These were identified using the devel_scripts/find_unused_imports.py script.
- Reverted the deletion of the Relax_disp.test_hansen_cpmg_data_to_lm63_3site system test which occurred in relax 3.2.3. See the thread at http://thread.gmane.org/gmane.science.nmr.relax.scm/21774/focus=6300 for the request that this deletion be reverted. This is the only system test for the LM63 3-site dispersion model using real data. Having this test allows for better coverage of the code.
- Updated the Relax_disp.test_hansen_cpmg_data_to_lm63_3site system test. This is for the changes to the optimisation user functions.
- Updated the checks in the Relax_disp.test_hansen_cpmg_data_to_lm63_3site system test. The values were incorrect due to a bug in relax and a non-optimal minfx setting (https://gna.org/bugs/?22210 and https://gna.org/bugs/?22211).
- Fix for a fatal bug for the prompt UI on MS Windows. The improvements in the tab completion support for the prompt UI on Mac OS X systems was fatal for certain Python readline modules on MS Windows, as readline.__doc__ can be None. This is now correctly handled.
- Decreased the precision the Relax_disp.test_hansen_cpmg_data_to_lm63_3site system test. This is to allow the test to pass on Mac OS X systems.
- Unit test fix for Mac OS X. This is for the test_ns_mmq_2site_korzhnev_2005_15n_dq_data_complex128 test of test_suite.unit_tests._lib._dispersion.test_matrix_exponential.Test_matrix_exponential. The tests no longer check for exact values, but use the assertAlmostEqual() calls instead.
- Deleted the ancient optimisation_testing.py development script, as this no longer works and is of no use.
- Implemented the pipe_control.mol_res_spin.format_info_full() function. This follows from http://thread.gmane.org/gmane.science.nmr.relax.scm/22522/focus=6534. This is a verbose representation of the spin information which can be used for presenting to the user. Functions for shorter string versions will also be of great use, for example as described by Troels at http://thread.gmane.org/gmane.science.nmr.relax.scm/22522/focus=6535.
- Created a unit test for the pipe_control.mol_res_spin.format_info_full() function. This comprehensive test covers all input argument combinations.
- Changed the behaviour of the pipe_control.structure.mass.pipe_centre_of_mass() function. This function returns the CoM and optionally the mass of the structural data loaded into the current data pipe. However it was matching the structural data to the molecule-residue-spin data structure and skipping spins that were deselected. This illogical deselection part has been eliminated, as spins can be deselected for various analysis purposes and this should not change the CoM. The deletion also significantly speeds up the function.
- Added Andy Baldwin's 2013 R
_{1ρ}relaxation dispersion model (BK13) to the manual. The model has been added to the table of dispersion models and to the dispersion software comparison table of the dispersion chapter of the manual. The citation has also been added to the bibliography. - The BK13 dispersion model is now properly added to the software comparison table.
- Added the 'BK13' and 'BK13 full' dispersion models to the to do section of the manual.
- Standardisation of the author names in the bibliography of the relax manual.
- Added links for the BK13 model to https://gna.org/support/?3155 in the manual.
- Expansion of the 'to do' section of the dispersion chapter of the manual.
- Editing of the 'to do' section of the dispersion chapter of the manual.
- Split out the interpolating in specific_analyses.relax_disp.data.plot_disp_curves() into separate function. This is to prepare for a interpolating function for spin-lock offset rather than spin-lock field strength for R
_{1ρ}models. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Split out the looping over frequency and offset into its own function, in function of specific_analysis.relax_disp.data.plot_disp_curves(). Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Split out the writing of dispersion graph files in specific_analyses.relax_disp.data.plot_disp_curves(). This is to prepare for a stand-alone function to plot R
_{1ρ}graphs, interpolating θ through spin-lock offset rather than spin-lock field strength. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Fix for function calling and default values of None in sub-plotting functions. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Large extension of specific_analyses.relax_disp.data(), by adding several helper plotting functions. This is to prepare for plotting R
_{1ρ}/R_{2}as function of effective field in rotating frame: ω_{eff}. R_{2}= R_{1ρ}/ sin^{2}(θ) - R_{1}/ tan^{2}(θ) = (R_{1ρ}- R_{1}* cos^{2}(θ) ) / sin^{2}(θ). Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Extended specific_analyses.relax_disp.optimisation.back_calc_r2eff() to handle interpolated spin-lock offset values. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Removed a wrong adding of empty offset dimension in the get_back_calc() function of target_functions.relax_disp(). Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added the back calculated R
_{2}as function of effective field in rotating frame: ω_{eff}. R_{1ρ}/R_{2}is defined as: R_{2}= R_{1ρ}/ sin^{2}(θ) - R_{1}/ tan^{2}(θ) = (R_{1ρ}- R_{1}* cos^{2}(θ) ) / sin^{2}(θ). This is described more at: http://wiki.nmr-relax.com/DPL94#Equation_-_re-writed_forms. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added an intermediate attempt to show the back calculated data in the graph for R
_{1ρ}/R_{2}as function of the effective field in rotating frame: ω_{eff}. The graph is aiming for the representation of Figure 2 in Kjaergaard et al 2013. (http://dx.doi.org/10.1021/bi4001062). The figure can be seen at https://gna.org/support/download.php?file_id=20208. It becomes clear, that it is not necessary interpolate through the spin-lock offset, but it is sufficient to interpolate through the spin-lock field strengths. The necessary step was the extraction of the effective field in rotating frame, ω_{eff}. In earlier attempt is shown at: http://wiki.nmr-relax.com/File:Matplotlib_52_N_R1_rho_R2eff_w_eff.png This though show lines for 6 offset values. The question is how to show the single line of interpolation. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added NMR library function to convert the given frequency from rad/s to ppm units. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Hard-coded restriction of R
_{1ρ}extra plotting to model DPL94, TP02, TAP03, MP05, NS R1rho 2-site. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Fix for sending the correct data structures to target function, and fix for the spin index which is always zero in graph production. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Moved the file_name creation out of the interpolate function, to make it a general function for interpolating. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Made both interpolation functions of the spin-lock field strength and spin-lock offset return the offset data. This is make it possible to switch between the interpolating functions, when plotting R
_{1ρ}graphs. This is necessary to produce the R_{2}as function of effective field in rotating frame ω_{eff}, and to produce R_{1ρ}as function of θ, when ramping the spin-lock offset. These graphs can be seen at: http://wiki.nmr-relax.com/Matplotlib_DPL94_R1rho_R2eff. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Changed interpolation function from offset to spin lock field strength, to plot R
_{1ρ}/R_{2}as function of effective field. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Improved axis label for plotting R
_{1ρ}/R_{2}as function of effective field ω_{eff}. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added sub-title to the plot of R
_{1ρ}/R_{2}as function of effective field. This is to add information about how the effective field has been interpolated. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added functionality to plot R
_{1ρ}/R_{2}as function of effective field ω_{eff}, for the R2eff model. Also renamed a function, to better reflect is functionality. The hard-coding of which models to plot, has been removed. If the exp-type is R_{1ρ}, then the plotting will commence. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added the spin specific residue name and spin_id to the title of the dispersion plots. This is handy, since it is often of interest to have this information at hand, when looking through many graphs. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Renamed and improved epydoc information for interpolating function for dispersion values. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Renamed the interpolating function for offset, and improved the epydoc information. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Corrected the epydoc information for the return_offset_data() function in specific_analyses.relax_disp.data. The function has been extended to return more data. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Renamed function to represent the functionality of returning data in correct xmgrace form. Also improved the epydoc information, for the return of values. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Renamed the other function to represent the functionality of returning data in correct xmgrace form. Also improved the epydoc information, for the return of values. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added function to calculate rotating frame parameters for lib/nmr.py. This function is called several times in specific_analyses/relax_disp/data.py by plotting functions. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Replaced repeated calculation of rotating frame parameters to use function in lib/nmr.py. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Skip production of plotting R
_{1ρ}/R_{2}as function of effective field ω_{eff}, when spin.isotope is not present. This can happen when it is 'exp_fit' model curve fitting. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added functionality to function to accept how the first part of the filename is formed. This is to prepare to reuse the same plotting function. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Renamed plotting sub function, to accept different file name arguments, and X-axis arguments. This is to reuse the sub-plot function to plot against different X-axis. Added plot of R
_{1ρ}as function of θ, where interpolated against spin-lock field strength. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Prepared flag, to tell which data type to interpolate through. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Preparation to interpolate through the offset to plot R
_{1ρ}as function of θ, interpolated through spin-lock offset. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added graph functionality, to plot R
_{1ρ}as function of θ, when spin-lock offset is interpolated. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Ensured production of plotting R
_{1ρ}/R_{2}as function of effective field ω_{eff}, when spin.isotope is not present. The offset in radians would be set to 0.0 instead. This can happen when it is 'exp_fit' model curve fitting. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added function to return spin info, and a function to return a spin string for graphs. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Replaced the spin info string in the title of graphs, with the new function method. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Added keywords to be used to backend function of plot_disp_curves. The keyword 'y_axis', determine which y data to be plotted on this axis. The keyword 'x_axis', determine which x data to be plotted on this axis. The keyword 'extend_hz' to determine how far to extend interpolated CPMG frequency or spin-lock field strenght. The keyword 'extend_ppm' to determine how far to extend interpolated spin-lock offsets. The keyword 'interpolate' to determine to interpolate dispersion points, or offset. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Made the plotting function uniform into accepting both CPMG and R
_{1ρ}data. Also made a function to return data, depending if it is data, back calculated, interpolated or residual. Sr #3124: Grace graphs production for R_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Renamed return grace data function, to a better shorter name. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Renamed the other return grace data function, to a better shorter name. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Hardcoded xmgrace colour_order, and made function to return data label, and data plot settings, depending on data type. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Renamed plotting function to represent the function of writing to file. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Removed unused plotting function. Sr #3124: Grace graphs production for R
_{1ρ}analysis with R_{2eff}as function of Ω_{eff}. Sr #3138: Interpolating θ through spin-lock offset Ω, rather than spin-lock field strength ω_{1}. - Streamlined plotting functions, to have similar input. Reordered the output from return_offset_data(), interpolate_disp() and interpolate_offset(), to reflect the order of data type. Made the input to return_grace_data_vs_disp(), return_grace_data_vs_offset the same(). Added the interpolate flag to return_grace_data_vs_disp() and return_grace_data_vs_offset(), to help return correct X-value. Added the interpolate flag to return_x_y_point(), to help determine if "disp point" or "offset point" should be returned. Added the "offset point" to return_x_y_point() function, to