## relax - News: relax version 3.1.0.

**relax version 3.2.3.**

*posted by bugman, Thu 03 Jul 2014 12:10:24 PM UTC - 0 replies*

**relax version 3.2.2.**

*posted by bugman, Thu 05 Jun 2014 02:15:52 PM UTC - 0 replies*

**relax version 3.2.1.**

*posted by bugman, Fri 23 May 2014 02:01:35 PM UTC - 0 replies*

**relax version 3.2.0.**

*posted by bugman, Wed 21 May 2014 12:12:14 PM UTC - 2 replies*

**relax version 3.1.7.**

*posted by bugman, Mon 17 Mar 2014 03:53:07 PM UTC - 1 reply*

[Submit News]

[65 news in archive]

### relax version 3.1.0.

*Item posted by Edward d Auvergne <bugman> on Thu 28 Nov 2013 02:48:17 PM UTC.*

### Description

After four years of development by numerous NMR spectroscopists, the relaxation dispersion analysis in relax is finally ready for release! This support is complete and includes almost all analytic and numeric dispersion models in existence. These have been labelled as 'R2eff', 'No Rex', 'LM63', 'LM63 3-site', 'CR72', 'IT99', 'TSMFK01', 'NS CPMG 2-site expanded', 'NS CPMG 2-site 3D', 'NS CPMG 2-site star', 'M61', 'DPL94', 'TP02', 'TAP03', 'MP05', 'NS R1rho 2-site', 'MQ CR72', and 'MMQ 2-site', mainly named after the authors and publication date. It includes support for single, zero, double, and multiple quantum CPMG data, including combined proton-heteronuclear data, and off-resonance R1rho data. An automated protocol has been developed to simplify the analysis and a GUI has been designed around this auto-analysis. Calculations have been parallelised at the spin cluster and Monte Carlo simulation level for speed.

### Download

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

### Full list of changes

Note this list is huge as it covers 4 years of development by numerous authors.

#### Features

- Full support for the analysis of relaxation dispersion data in the prompt, scripting, and graphical user interfaces.
- Support for single quantum (SQ), zero quantum (ZQ), double quantum (DQ), and multiple quantum (MQ) CPMG-type data.
- Support for R1rho-type data.
- Support for combined proton-heteronuclear SQ, ZQ, DQ, and MQ CPMG-type data (multiple-MQ or MMQ data).
- The 'R2eff' model - used to determine the R2eff or R1rho values and errors required as the base data for all other models.
- The 'No Rex' model - the model for no chemical exchange being present.
- The 'LM63' SQ CPMG-type analytic model - the original Luz and Meiboom 1963 2-site fast exchange equation with parameters {R20, ..., phi_ex, kex}.
- The 'LM63 3-site' SQ CPMG-type analytic model - the original Luz and Meiboom 1963 3-site fast exchange equation with parameters {R20, ..., phi_exB, k_B, phi_exC, k_C}.
- The 'CR72' SQ CPMG-type analytic model - the reduced Carver and Richards 1972 2-site equation for most time scales whereby the simplification R20A = R20B is assumed with the parameters {R20, ..., pA, dw, kex}.
- The 'CR72 full' SQ CPMG-type analytic model - the full Carver and Richards 1972 2-site equation for most time scales with parameters {R20A, R20B, ..., pA, dw, kex}.
- The 'IT99' SQ CPMG-type analytic model - the Ishima and Torchia 1999 2-site model for all time scales with pA >> pB and with parameters {R20, ..., phi_ex, pA.dw^2, kex}.
- The 'TSMFK01' SQ CPMG-type analytic model - the Tollinger et al., 2001 2-site very-slow exchange model for time scales within range of microsecond to second time scale with parameters are {R20A, ..., dw, k_AB}.
- The 'NS CPMG 2-site expanded' SQ CPMG-type numeric model - A model for 2-site exchange expanded using Maple by Nikolai Skrynnikov (Tollinger et al., 2001) with the parameters {R20, ..., pA, dw, kex}.
- The 'NS CPMG 2-site 3D' SQ CPMG-type numeric model - the reduced model for 2-site exchange using 3D magnetisation vectors whereby the simplification R20A = R20B is assumed with the parameters {R20, ..., pA, dw, kex}.
- The 'NS CPMG 2-site 3D full' SQ CPMG-type numeric model - the full model for 2-site exchange using 3D magnetisation vectors with parameters {R20A, R20B, ..., pA, dw, kex}.
- The 'NS CPMG 2-site star' SQ CPMG-type numeric model - the reduced model for 2-site exchange using complex conjugate matrices whereby the simplification R20A = R20B is assumed with the parameters {R20, ..., pA, dw, kex}.
- The 'NS CPMG 2-site star full' SQ CPMG-type numeric model - the full model for 2-site exchange using complex conjugate matrices with parameters {R20A, R20B, ..., pA, dw, kex}.
- The 'M61' R1rho-type analytic model - the Meiboom 1961 2-site fast exchange equation for on-resonance data with parameters {R1rho', ..., phi_ex, kex}.
- The 'M61 skew' R1rho-type analytic model - the Meiboom 1961 2-site equation for all time scales with pA >> pB and with parameters {R1rho', ..., pA, dw, kex}.
- The 'DPL94' R1rho-type analytic model - the Davis et al., 1994 2-site fast exchange equation extending the 'M61' model for off-resonance data with parameters {R1rho', ..., phi_ex, kex}.
- The 'TP02' R1rho-type analytic model - the Trott and Palmer 2002 2-site equation for all time scales with pA >> pB and with parameters {R1rho', ..., pA, dw, kex}.
- The 'TAP03' R1rho-type analytic model - the Trott et al., 2003 off-resonance 2-site equation for all time scales with the weak condition pA >> pB and with parameters {R1rho', ..., pA, dw, kex}.
- The 'MP05' R1rho-type analytic model - the Miloushev and Palmer 2005 off-resonance 2-site equation for all time scales with parameters {R1rho', ..., pA, dw, kex}.
- The 'NS R1rho 2-site' R1rho numeric model - the model for 2-site exchange using 3D magnetisation vectors with the parameters {R1rho', ..., pA, dw, kex}.
- The 'MQ CR72' MMQ-type analytic model - the Carver and Richards 1972 2-site model for most time scales expanded for MMQ CPMG data by Korzhnev et al., 2004 with the parameters {R20, ..., pA, dw, dwH, kex}.
- The 'MMQ 2-site' MMQ-type numeric model - the model for 2-site exchange whereby the simplification R20A = R20B is assumed with the parameters {R20, ..., pA, dw, dwH, kex}.
- An automated protocol for relaxation dispersion which includes sequential optimisation of the models, fixed model elimination rules to remove failed models and failed MC simulations increasing both parameter reliability and accuracy (d'Auvergne and Gooley 2006), and a final run whereby AIC model selection is used to judge statistical significance.
- Additional methods to speed up the auto-analysis by skipping the grid search: Model nesting, the more complex model starts with the optimised parameters of the simpler; Model equivalence, when two models have the same parameters; And spin clustering, the analysis starts with the averaged parameter values from a completed non-clustered analysis.
- Parallelisation of the dispersion analysis at the level of the spin cluster and Monte Carlo simulation for fast optimisation on computer clusters using OpenMPI.

#### Changes

- Started to implement the framework for relaxation dispersion system tests.
- Copied 'test_suite/system_tests/relax_fit.py' for relaxation dispersion.
- Started to implement relaxation dispersion system tests.
- Created the user_functions.relax_disp module by copying user_functions.relax_fit. This file now needs to be modified to suit the needs of relaxation dispersion.
- Manually created the relax_disp user functions. This is equivalent to Seb's commit for the prompt.relax_disp module. The equivalent changes to the user_functions.relax_disp were hand edited. Added functions to select the experiment type and mathematical model used. These functions allow the user to select the experiment type (cpmg or r1rho) as well as the mathematical model to fit the data (fast or slow).
- Copied the 'relax_fit.py' script to 'relax_disp.py'. This file, obviously, will need to be modified to suit the needs of the relaxation dispersion code.
- Modified the script so it will test for fast-exchange curve fitting from CPMG data. Data and functions to treat it are still missing.
- Added a test for CPMG data in slow-exchange and changed the name of the test for fast-exchange.
- Copied the 'relax_fit.py' specific functions to 'relax_disp.py'. The code will now need many many many changes to suit the needs of relaxation dispersion.
- Made a few changes towards a functional relaxation dispersion code. This includes several modifications as well as the addition of the exp_type() function.
- Moved the relax_time() function to cpmg_frq() and made other small changes. Still much (!) work is needed for this code to be complete.
- Renamed 'cdp.frq' to 'cdp.cpmg_frqs' so it is not confusing with the spectrometer frequency. Indeed, 'cdp.cpmg_frqs' points to the CPMG pulse train frequency (nu_cpmg).
- Changed all instances of 'relax_times' to 'cpmg_frqs' and made other small changes.
- Changed 'relax_time' instances to 'cpmg_frq'.
- Changed the index name and description. The description might change later to be more appropriate when the code is more mature...
- Included the setting of the spectrometer frequency and uncommented a few lines of code. Of course, this won't work until the sample data has been introduced and the right names for the different files be input in the system test script...
- Fixed many formatting errors and made the 'relax_disp' code accessible (pipes, interpreter, etc.). These changes also include a coming back to using the C code 'math_fns/relax_fit.py' since there is still no such code associated to relaxation dispersion. This will allow working in the code without relax crashing and complaining about the lack of a C module name 'relax_disp.py'.
- Added the user function cpmg_delayT() which allows setting the CPMG constant time delay T used for the analysed dataset. This follows a post at https://mail.gna.org/public/relax-devel/2009-01/msg00027.html.
- Made a few changes so the cpmg_delayT() function now works.
- Added the user function cpmg_frq() and added examples to the user function cpmg_delayT().
- Corrected remaining frq instances to cpmg_frq when appropriate to avoid confusion and corrected a few related things in the system test script.
- Made the cpmg_frq() function accept only None for the reference spectrum and corrected a typo.
- Added the parameters for the slow- and fast-exchange regime.
- Added the parameters for the slow- and fast-exchange regime in the function data_names().
- Corrected a few formatting issues and still added parameters for the slow- and fast-exchange regime.
- Corrected a few formatting issues and still added parameters for the slow- and fast-exchange regime. Formatting issues corrected were spotted by Ed in a post at https://mail.gna.org/public/relax-devel/2009-01/msg00045.html.
- A bit more changes to introduce parameters for CPMG relaxation dispersion.
- Introduced CPMG parameters into the function return_grace_string() and corrected formatting issues.
- Introduced relaxation dispersion parameters in the function return_data_name().
- Changed the default cpmg_frq value in cpmg_frq() from 0 to None.
- Added a relaxation dispersion dataset in the system-test. This was kindly provided by Dr Flemming Hansen (flemming AT pound DOT med DOT utoronto DOT ca) and was previously published in Hansen, Vallurupalli & Kay (2008) J. Phys. Chem. B, 112, 5898-5904. The original format was different and was modified to better suit the way relax handles datasets. Finally, the information contained here were written in a 'readme' file placed in the same directory as the dataset itself to allow referencing and acknowledgments.
- Added 'Sparky' formatted files to the system-test so the files can be input and development of the branch continued.
- Changed the format of the CPMG frequency and corrected the names of some input files.
- Added an unresolved file to meet the script requirements.
- Copied the script for the fast-exchange regime to the slow-exchange regime.
- Modified the newly copied script so it is effectively for the slow-exchange regime.
- Added details to the readme file and changed the directory name where the sample data is located. The directory is now named 'dataset_1-a'. This contains data recorded at 500 MHz. Data recorded at 800 MHz will be put in a directory called 'dataset_1-b'.
- Created a directory for the data recorded at 800 MHz and put a readme file explaining its origin.
- Added the relaxation dispersion dataset recorded at 800 MHz in the system-test. This was kindly provided by Dr Flemming Hansen (flemming AT pound DOT med DOT utoronto DOT ca) and was previously published in Hansen, Vallurupalli & Kay (2008) J. Phys. Chem. B, 112, 5898-5904. The original format was different and two formats were made ('generic' and 'sparky'), as for the dataset recorded at 500 MHz.
- Renamed the directories containing the sample datasets provided by Flemming Hansen. The names are now more obvious as to their content... This was proposed by Ed in a post at https://mail.gna.org/public/relax-devel/2009-01/msg00056.html.
- Added an 'unresolved' file to the 800 MHz data and moved (and modified) some files (sequence and readme) so there is only one copy for the 500 and 800 MHz data. This prevents duplicated files.
- Changed the object names so they are lower case as they should be, based on the rest of the code. Made the equivalent change in the function assemble_param_vector() to allow the system-test to go further.. This was spotted by Ed in a post at https://mail.gna.org/public/relax-devel/2009-01/msg00058.html.
- Corrected capitalisation issues for param names. These were spotted by Ed in a thread starting at https://mail.gna.org/public/relax-devel/2009-01/msg00059.html.
- Rearranged commands in the scripts. The experiment type and exchange regime will have to be input before the cpmg pulse train delay T.
- Introduced a RelaxError when chosing 'r1rho' as experiment type as this won't be implemented now. Efforts will be concentrated on the CPMG code first, then on the R1rho code.
- Added tests, print statements and other code to the relaxation dispersion specific functions. Tests were proposed by Ed in a post at https://mail.gna.org/public/relax-devel/2009-01/msg00065.html.
- Started to implement a function for calculating the effective transversal relaxation rate (R2eff). This follows a thread at https://mail.gna.org/public/relax-devel/2009-01/msg00067.html.
- Converted the function linear_constraints() for relaxation dispersion needs.
- Started to implement the scaling matrix for scaling the 'R2eff' values. This might change in the future as other possible curve fitting parameters ('R2', 'Rex', 'kex', 'R2A', 'kA', 'dw') might need some scaling.
- Completed the scaling matrix code. This follows a thread at https://mail.gna.org/public/relax-devel/2009-01/msg00073.html.
- Imported relaxation dispersion in grace user functions.
- Added a missing quote which prevented the user manual to be sconstructed. This was discussed in a thread starting at https://mail.gna.org/public/relax-devel/2009-01/msg00082.html.
- Started to implement a function for reading 'R2eff' values directly. This is as proposed in a post at https://mail.gna.org/public/relax-devel/2009-01/msg00020.html. The function does not contain code yet.
- Started to put equations and references in the user function docstrings and also corrected a small typo. This was proposed by Ed in a post at https://mail.gna.org/public/relax-devel/2009-01/msg00028.html.
- Corrected the way the scaling matrix is assembled. This is as proposed by Ed in a post at https://mail.gna.org/public/relax-devel/2009-01/msg00079.html. The scaling values are now based on the default values for the different parameters which were slightly modified. The only parameter for which the average is still used (as for intensities in the 'relax_fit.py' code) is 'R2eff'.
- Continued to implement the user function calc_r2eff(). This follows a discussion at https://mail.gna.org/public/relax-devel/2009-01/msg00067.html.
- Copied 'test_relax_fit.py' to 'test_relax_disp.py'. This will allow the design of a few unit tests for the relaxation dispersion code.
- Added two unit tests for the relaxation dispersion code and fixed errors in the corresponding code. More unit tests will be added soon to help debugging and developing.
- Added two more unit tests.
- One more unit test.
- One more unit test for the relaxation dispersion code.
- Added more unit tests and tried to debug what was uncovered by these tests. Still more work is needed for debugging...
- A few fixes based on the unit tests problems.
- Changed the default value for 'int_cpmg' to avoid an impossible mathematical situation: ln(0).
- Fixed a bug where the 'id' argument was not set. This was proposed by Ed in a post at https://mail.gna.org/public/relax-devel/2009-01/msg00127.html.
- Started to make changes for multiple field relaxation dispersion analysis. This seems necessary, so maybe we should not support single field analysis of relaxation dispersion at all. -> Kovrigin et al. (2006) JMagRes, 180: 93-104. The changes made here are only a first draft and may not work. In particular, maybe the spectrum.read_intensities(), relax_disp.cpmg_frq(), spectrum.replicated(), spectrum.error_analysis(), and deselect.read() functions will need to know the magnetic field to which the particular dataset is associated... In fact, the different datasets should be input first and their R2eff calculated independently. In a second step, the actual relaxation dispersion curve fitting should be made with all data.
- Fixed a bug which prevented the manual pdf to be compiled. The problem was caused by a ':' character in the references (after the volume number, as usual). This was changed for a '.' character. Equations were fine.. Moreover, a better formatting was done by adding ':' characters after the word 'are' before enumerations.
- Fixed the unit tests. This is as proposed by Ed in a post at https://mail.gna.org/public/relax-devel/2009-01/msg00132.html.
- Started to implement the reading of 'r2eff' by relax_data.read() by first writing a system test.
- Updated a few dosctrings and tried to improve the system test.
- Removed the obsolete function 'relax_disp.r2eff_read()'. R2eff values will be read directly by 'relax_data.read()'.
- Reordered a few functions for alphabetical reasons.
- A small fix to the system test. However, is this fix the solution or is there something wrong with the reading of data (such as 'R2eff') by relax_data.read()? Shouldn't the data, for example 'R2eff', be available in 'cdp.mol[0].res[0].spin[0].R2eff_val[0]' or 'cdp.mol[0].res[0].spin[0].R2eff[0]' for the 1st spin of the 1st residue in the 1st molecule?
- Fixed an import (as well as a few comments). This however introduces an error concerning the 'chi2' being undefined in the C module for relaxation dispersion...
- Solved an issue created during the merge process concerning the 'return_data_name_doc' call. The solution is based on the code in 'specific_fns/relax_fit.py'.
- Brought the relaxation dispersion branch into sync with the 1.3 line. There were many design changes within the 1.3 line that required that the old relaxation dispersion code be updated.
- Fixes for the relaxation dispersion system tests. The install path is now in the status object, and not in
*_main_*. - GPLv3 license updates for all files not found in the trunk.
- Import fixes for the specific_analyses.relax_disp due to the recent trunk package layout redesign.
- Made the non-API methods of the specific_analyses.relax_disp.Relax_disp class private.
- Improvements for the GUI representation of the relax_disp user functions.
- More import fixes for the new package layout.
- Fix for the relax_data.read user function call in the Relax_disp.test_read_r2eff system test. The column numbers must be supplied.
- Some more fixes to make the Relax_disp.test_read_r2eff system test pass. These are again changes needed due to the trunk now being very different.
- The cpmg_frq argument of the relax_disp.cpmg_frq user function can now be None.
- The cpmg_frq argument of the relax_disp.cpmg_frq user function can now be an integer as well as a float.
- Updates for the relaxation dispersion system test scripts for the newer design of relax. A number of changes were required as the code was quite old.
- Created the lib.dispersion.equations module. This is a translation of Sebastien Morin's C code in the old relax_disp branch.
- Created a very basic initial target function class for relaxation dispersion. This code is a translation of Sebastien Morin's C code in the old relax_disp branch.
- The relaxation dispersion specific analysis code now uses the Python target function rather than the C.
- Fix for the Relax_disp.test_curve_fitting_cpmg_fast system test variable names.
- Added the model argument to the dispersion target function class to select between different equations.
- The relaxation dispersion target function class now imports the equations from lib.dispersion.equations.
- The relaxation dispersion target function class raises a RelaxError when the model is not implemented.
- Modified all the relaxation dispersion test data Sparky files at 800 MHz. The last three lines of the files were not properly formatted.
- Converted all of the raising of RelaxErrors in the specific_analyses.relax_disp to the new standard. This is for Python 3 support.
- Converted all print statements in specific_analyses.relax_disp to function calls. This is for Python 3 compatibility.
- Converted the prompt unit tests for relaxation dispersion to the current relax design.
- Updated the target_functions package
*_all_*list for the relax_disp module. - Another fix for the prompt argument unit tests of the relax_disp user functions.
- Big changes to the front end of the relax_disp.select_model user function. The model strings have been changed and are now programmatically added to the user function documentation. The main text has also been redesigned. And the new model 'exp_fit' has been added which allows just the exponential curves to be fit.
- Python 3 import fix for the specific_analyses.relax_disp module.
- Updated the documentation in specific_analyses.relax_disp to use the user_functions package design. The user_functions.objects.Desc_container and user_functions.data.Uf_tables objects are now used to construct the relaxation dispersion documentation.
- The relax_disp.select_model backend now handles the 'exp_fit' model.
- Removed all aliasing of the current data pipe in specific_analyses.relax_disp as this is in
*_builtin_*. - The specific_analyses.relax_disp module now uses the parameter list object to define parameters. This allows the now unused methods data_names(), default_value(), return_data_name(), and return_grace_string() to be deleted and their contents copied into the parameter definitions in the class
*_init_*() method. - Alphabetical arrangement of methods in the specific_analyses.relax_disp module.
- Docstring cleanups for the specific_analyses.relax_disp module.
- The relaxation dispersion specific analysis now aliases API base methods for a number of methods.
- Import cleanup in the specific_analyses.relax_disp module.
- The relaxation dispersion specific analysis module is now using the base _data_init_spin() method. This is aliased to data_init() and replaces the old non-functional method.
- Created the relax_disp.spin_lock_field user function. This is used to set the spin-lock field strength of a given R1rho spectrum.
- Created the relax_disp.relax_time user function. This is almost a direct copy of the relax_fit.relax_time user function, but has been modernised.
- Fix for the printout from the relax_disp.relax_time user function - the time is no longer divided by 1k.
- Expanded the dispersion model parameters to include the exponential curve parameters.
- Clean up of some of the old relax_disp user functions - many argument types are now numbers rather than floats.
- Unit test fixes for the prompt relax_disp user function argument checks.
- Added the specific_analyses.relax_disp module to the unit test checking of the specific API.
- Big cleanup of the relaxation dispersion code to match the analysis specific API. All methods not belonging to the API have been made private. The arguments and keyword arguments for the API methods now match the API.
- Completely redesigned the minimisation parts of the specific_analyses.relax_disp module. Instead of dealing with the optimisation of individual spins, groups of spins are now optimised together. This allows for the clustering analysis of relaxation dispersion. The method _block_loop() has been created to loop over spin blocks, but it currently only returns individual spins. However with the rest of the code designed to handle this loop, only this function needs to be modified to enable clustering. The method _param_num() has also been added to determine the total parameter number per spin block. The data structures sent into the Dispersion target function class have also been redesigned to handle spin blocks instead of individual spins.
- Modified the relax_disp.cpmg_frq user function to match relax_disp.spin_lock_field. Both the front and back ends now use the same logic as the relax_disp.spin_lock_field user function and will allow some sanity to the analysis specific code.
- The relax_disp.cpmg_frq and relax_disp.spin_lock_field user functions now create cdp.curve_count. This is an integer which indicates the number of exponential curves which are to be optimised per spin block.
- The relaxation dispersion analysis specific _param_num() method now takes the number of curves into account.
- Better setup checking for the relaxation dispersion specific analysis minimise() method.
- Renamed cdp.curve_type to cdp.model to better explain the variable.
- Fixes for the dispersion specific analysis separating R2eff from R2. There is one R2eff parameter per exponential curve, but only one R2 per model. The code now better handles this.
- The dispersion specific methods now handle one R2eff and I0 parameter per exponential curve.
- Better management of the global relaxation dispersion data. The user functions relax_disp.cpmg_frq, relax_disp.spin_lock_nu1, and relax_disp.relax_time now maintain data structures in the current data pipe of the unique frequencies, fields, and times (sorted) as well as the number of frequencies, fields, and times. This data is used by the minimise user function back end to set up the target function, and will be required by many other parts of the analysis.
- The dispersion specific _assemble_param_vector() method now handles multiple R2eff and I0 values. These spin structures are dictionaries holding multiple values.
- Created the dispersion specific _exp_curve_loop() method for looping over each exponential curve. This yields the index and key for each curve, simplifying the handling of this data.
- Expanded the relax_disp.select_model user function documentation to cover R2eff and I0. These parameters and how they are optimised are now better described.
- Updated the relaxation dispersion target function class to handle the recent changes.
- First attempt at a target function for fitting exponential curves for relaxation dispersion.
- Added some synthetic data to test the 'exp_fit' relaxation dispersion model fitting. These are just basic synthetic exponential curves. R2eff and I0 should be very easy to find.
- The lib.software.sparky.read_list_intensity() function can now handle lowercase in the residue names.
- Created the Relax_disp.test_exp_fit system test for checking the relaxation dispersion 'exp_fit' model.
- The specific_analyses.relax_disp module is now using minfx correctly. The minfx grid search is no longer part of generic_minimise() and must be called separately.
- The relax_disp function _grid_search_setup() now operates in the same way as the relax_fit code. This function originates from the 'relax_fit' specific analysis code, but that code has since evolved. The 'relax_disp' code now mimics the new code, returning lists of grid search increments and upper and lower limits.
- The scaling flag is now initialised in the relaxation dispersion target function class.
- Created the lib.curve_fit package and associated unit tests. This will be used for holding modules such as for exponential curve-fitting required for the relaxation dispersion analysis.
- Created the new lib.curve_fit.exponential module for exponential curve-fitting. This contains the single exponential_2param_neg() function which will be used for the relaxation dispersion target functions. This is based on Sebastien Morin's function exp_2param_neg in maths_fns.exponential.c in his dormant inversion-recovery branch.
- Typo fix for the new lib.curve_fit.exponential.exponential_2param_neg() function.
- The relaxation dispersion func_exp_fit() target function now uses exponential_2param_neg(). This is from the lib.curve_fit.exponential module.
- Fix for the relaxation dispersion specific _assemble_scaling_matrix() method. The values were all inverted - the matrix should hold values on the same order as the parameter values.
- Fix for the func_exp_fit() relaxation dispersion target function. The parameter index was not correctly calculated.
- The 'exp_fit' relaxation dispersion model now uses the minfx.grid sparseness argument. This is used to skip all parts of the grid search belonging to a different exponential curve or different spin. If the number of curves is N and the number of spins M, the grid size decreases from inc**(2*N*M) to (inc**2)*N*M. For lots of spins and curves, this is a huge decrease.
- The relaxation dispersion specific _disassemble_param_vector() method is now functional. This should allow the minimise user function to complete.
- Fixes for the dispersion specific _assemble_param_vector() method. The R2eff and I0 spin dictionary structures are now checked for their keys before pulling the value out.
- Fix for the relaxation dispersion grid search. The lower and upper bounds are no longer continually scaled with each optimisation.
- Increased the speed of the Relax_disp.test_exp_fit system test by using a smaller grid search.
- The relaxation dispersion target function class back_calc variable now matches the values variable. Instead of being a temporary structure which is overwritten for each spin and each exponential curve, the structure now matches the dimensions of the values variable and hence is persistent per function call. This allows external code to access the structure - for example for data back calculation in the relaxation dispersion specific analysis module.
- Fixes for the dispersion specific _back_calc() method. This method still has a long way to go before it is of any use.
- Created a custom base_data_loop() method for the relaxation dispersion analysis. This defines the base data as the peak intensities of a single exponential curve and yields the spin container and exponential curve key identifying the individual curves.
- Activated Monte Carlo simulations for the relaxation dispersion analysis. This required a bit of work. The key parts were renaming _block_loop() to the API method model_loop() as that is exactly what the model_loop() method is supposed to do, converting a bunch of API common spin-based methods to handle dispersion clustering, and to modify existing methods from Seb's original branch to handle the base_data_loop() method. The following methods have been added or modified. _back_calc(): This method has been modified to handle clustering and the returning of peak intensities from only one exponential curve. _exp_curve_index_from_key(): This new method is used to convert exponential curve key into the corresponding index. _intensity_key(): This new method is for converting an exponential curve key and relaxation time into the corresponding intensity key. create_mc_data(): This method is now functional and handles the data from the base_data_loop() method. return_error(): This method now handles the data from the base_data_loop() method. set_selected_sim(): This new method has been modified from the common _set_selected_sim_spin() method but modified for the model_loop() method. sim_pack_data(): This method now handles the data from the base_data_loop() method. sim_return_param(): This new method has been modified from the common _sim_return_param_spin() method to suit the model_loop(). sim_return_selected(): This new method has been modified from the common _sim_return_selected_spin() method again to suit the model_loop().
- Modified the Relax_disp.test_exp_fit system test to be faster and not create plots which it cannot.
- The Relax_disp.test_exp_fit system test now checks some of the final results.
- The relaxation dispersion parameter errors from Monte Carlo simulations are now stored. Previously MC simulations could run, but the errors were not being calculated and stored. The sim_return_param() method was empty. This method is now complete. In addition the set_error() method has been created for setting the parameter errors. And the _exp_curve_key_from_index() and _param_index_to_param_info() auxiliary methods added to facilitate data access.
- Expanded the checking in the Relax_disp.test_exp_fit system test.
- Converted all relaxation dispersion parameters to lowercase. This is so the variable names match the parameter names identically, avoiding problems with some of the shared methods of the specific analysis API.
- The spin parameters are now set up last by the relax_disp.select_model user function back end.
- Added 'spin_lock_nu1' as a dictionary type parameter of the relaxation dispersion specific analysis.
- Rearrangements of the 2 system tests of Fleming Hansen's CPMG data. The system tests are now called Relax_disp.test_hansen_cpmg_data_fast_2site and Relax_disp.test_hansen_cpmg_data_slow_2site, and the system test scripts are now all in test_suite/system_tests/scripts/relax_disp/.
- Created a basic initial auto-analysis script for relaxation dispersion. This currently only supports the optimisation of the 'exp_fit' diffusion model, but has all of the infrastructure set up to make it easy to add other models.
- Added the relaxation dispersion module to the auto_analyses package
*_all_*list. - The relaxation dispersion system test class now imports the auto-analysis. This fixes an import order error.
- The Relax_disp.test_exp_fit system test now uses the auto_analyses.relax_disp analysis.
- Fix for the relaxation dispersion auto-analysis. The exponential fit model is now selected prior to optimisation.
- Removed the relax_disp.select_model user function call from the exp_fit dispersion system test script. This is performed by the auto-analysis and not during setup.
- Added testing for spin clustering to the Relax_disp.test_exp_fit system test. This includes calls to the new relax_disp.cluster user function and the checking of pipe variables holding the clustering information.
- Fix for the spin ID string for the relax_disp.cluster user function. This is for the exp_fit.py relaxation dispersion system test script.
- Implemented the relax_disp.cluster user function. This is for clustering spins together for a dispersion analysis.
- Clustering is now enabled for relaxation dispersion. The model_loop() analysis specific API method now loops over the spin clusterings, allowing a cluster of spins to be optimised simultaneously to one set of model parameters.
- Fixes for the spin clustering for relaxation dispersion. Both optimisation and Monte Carlo simulations were affected by these bugs.
- Speed up of the Relax_disp.test_exp_fit system test by cutting the grid size down to 3 increments.
- Expanded the write_results() method of the relaxation dispersion auto-analysis. More Grace graphs are now being produced, and the Rex file creation is now model dependent.
- Fix for the relax_disp.cluster user function. The 'free spins' category is now not deleted when empty.
- Created an icon set for relaxation dispersion.
- Renamed the relaxation dispersion test suite data directory to 'dispersion'.
- Changed the relax_disp.cpmg_frq user function id argument to spectrum_id. All the relax_disp user functions now operate with the spectrum IDs instead of experiment IDs.
- The relax_disp.cpmg_delayT user function backend now uses the spectrum ID rather than experiment ID.
- Expanded the relax_disp.exp_type user function to include the fixed period CPMG experiments.
- The relax_disp.cpmg_delayT backend can now handle the 'cpmg fixed' experiment type.
- The relax_disp.cpmg_frq user function can now handle values of None. The float function is no longer used if the value of None is encountered.
- Updated the dispersion system test script for Flemming Hansen's data. This script should now be close to the final form for a relaxation dispersion analysis of CPMG data with a fixed relaxation time period.
- Combined all the system test scripts of Flemming Hansen's fixed time period CPMG data. For details of this data, see http://thread.gmane.org/gmane.science.nmr.relax.devel/3790/focus=3827.
- Fixes for the renaming of the relaxation dispersion test suite shared data directory.
- Started to redesign how R2eff is handled in the relaxation dispersion analysis. Instead of being part of the optimisation of the dispersion model, it will itself be the model named 'R2eff' (converted from the 'exp_fit' model). This model will either use the calc user function to determine R2eff when the fixed relaxation period experiment is selected, or fit exponential curves using the relax_fit C module for the variable relaxation period experiments. The R2eff values will then be copied over for each dispersion model in the auto-analysis using the value.copy user function.
- Created the relax_disp.plot_exp_curves user function. This is to be used to create 2D graphs of the exponential curves (relaxation time verses peak intensity) as the grace.write user function plots are not very nice - the curves from each spectrometer field strength and dispersion point are mixed into one curve.
- The relaxation dispersion auto-analysis is now created plots of the exponential curves.
- The R2eff model now works for the variable time relaxation period and exponential curve-fitting.
- The relax_disp.select_model user function now checks for the compiled C module when required.
- Expanded the new analysis wizard in the GUI to accommodate the relaxation dispersion auto-analysis. Now the buttons are a matrix of 4x2 with the NOE, R1, R2, and model-free analyses at the top and two new blank buttons have been added to the bottom. One will be used for the dispersion analysis.
- Created some basic graphics for the relaxation dispersion analysis fur use in the GUI.
- Added the correct sized graphic for the relaxation dispersion button in the new analysis wizard.
- Created the relaxation dispersion button in the new analysis wizard.
- Created the initial version of the relaxation dispersion auto-analysis GUI frame. This is built from copying lots of code from the NOE, R1, and R2 analyses. The dispersion specific parts will be added later.
- The relaxation dispersion GUI analysis now has an element for selecting the models to be optimised.
- Removed some unneeded checks in the relax_disp.exp_type user function.
- Added a GUI element to the relaxation dispersion auto-analysis for selecting the experiment type.
- The relax_disp.exp_type user function has been shifted to the new analysis wizard. Instead of being one of the elements on the relaxation dispersion analysis frame, it is now placed between the analysis selection page and the data pipe page of the new analysis wizard. The user function execution is delayed until the set up of the frame, just after the execution of the pipe.create user function. This will allow the frame to be set up differently for each experiment type.
- Extended the tooltip for the experiment type GUI element in the relaxation dispersion frame.
- Improvements to the tooltips in the relaxation dispersion analysis frame of the GUI.
- Changed the peak intensity wizard for the relaxation dispersion frame to match the other analyses.
- Unused import removal from the gui.analyses.auto_relax_disp module.
- Missing import in the gui.analyses.auto_relax_disp module.
- Added support for all the relaxation dispersion user functions in the Peak_intensity_wizard object.
- Modified how the fixed time period is specified in the Flemming Hansen data system test. Instead of using relax_disp.cpmg_delayT user function, the relax_disp.relax_time user function will be used. The functionality is duplicated and relax_disp.cpmg_delayT is not needed.
- Modified the Spectra_list GUI element to handle relaxation dispersion data.
- The relaxation dispersion GUI analysis now uses the dispersion parts of the peak intensity elements. This includes activating the dispersion parts of the Spectra_list GUI element for displaying the spectrum ID with associated metadata and the dispersion parts of the Peak_intensity_wizard for loading the data.
- The relaxation dispersion auto-analysis is now correctly executed from the GUI. The GUI data gathering is also now complete in the assemble_data() method.
- Added some more module variables to specific_analyses.relax_disp for the experiment types.
- The relaxation dispersion auto-analysis now performs the peak intensity error analysis. This is essential for when the GUI is used.
- More Unicode characters are now used in the relaxation dispersion GUI analysis frame. The model parameter lists have also been improved.
- Removed the spectrum.error_analysis user function call in the exp_fit.py dispersion system test script. This is now performed by the auto-analysis.
- Fixed for the error_analysis() method of the relaxation dispersion auto-analysis. The method can now handle missing spectrometer field strength data.
- More fixed for the peak intensity error analysis method of the relaxation dispersion auto-analysis. The fixed relaxation time period type experiments can now be handled.
- Elimination of the relax_disp.cpmg_delayT user function. This user function is not necessary as the relax_disp.relax_time user function serves the same purpose. The use of relax_disp.relax_time instead allows for code sharing between the fixed and variable time period relaxation dispersion experiment types.
- Elimination of the relax_disp.calc_r2eff user function. This user function, which is non-functional anyway, is not needed. The calculation of the R2eff values will occur with the optimisation of the 'R2eff' model (with a call to the calc user function for the fixed time period experiment types) so direct calculation through a specific user function is not needed.
- Improvements to the GUI text subscripting in the relaxation dispersion analysis frame.
- Removed the temporary relaxation dispersion SVG graphic for the GUI analysis.
- Redesign of the graphic for the relaxation dispersion analysis. This is a modification of the r1.svg graphic to show roughly the graphic as in "Protein NMR Spectroscopy, Principles and Practice" by Cavanagh, Fairbrother, Palmer and Skelton.
- Editing of the relaxation dispersion analysis graphic.
- Added the relaxation dispersion graphic to all of the dispersion GUI user functions missing a graphic.
- Redesign of the relaxation dispersion models in the relax_disp.select_model user function front-end. The models have been renamed and better defined based on the experiment type (CPMG or R1rho).
- The relaxation dispersion scaling matrix assembly now uses lib.mathematics.round_to_next_order(). This allows the printed out I0 values for the optimisation of the exponential curves to be easier to scale back to the real value.
- The Relax_disp.test_hansen_cpmg_data_fast_2site system test now uses the R2eff model. The equivalent slow exchange system test also uses the model. This model will be used to find the R2eff values from the fixed relaxation time period data.
- Fix for some RelaxError printouts in the relaxation dispersion specific code.
- The relaxation dispersion class variables for the experiment types are now used for all comparisons. This should avoid random bugs.
- Fix for the calculation part of the relaxation dispersion auto-analysis. This is for the fixed relaxation period data types.
- The 2D Grace plots of the exponential curves are now skipped for the fixed relaxation period data types. This is in the relaxation dispersion auto-analysis.
- Started to implement the relaxation dispersion analysis specific calculate() method. This will be used to calculate the R2eff/R1rho values for the fixed relaxation time period data types and is equivalent to Sebastien Morin's relax_disp.calc_r2eff user function which was deleted (see http://thread.gmane.org/gmane.science.nmr.relax.scm/17336).
- Converted the specific_analyses.relax_disp module into its own package. This is to allow the code to be broken up into separate modules to simplify the analysis.
- Shifted out all of the variables and dispersion data specific code into separate modules. The dispersion data private methods have been converted into functions of the specific_analyses.relax_disp.disp_data module. The package variables have also been shifted into the specific_analyses.relax_disp.variables module to avoid circular imports.
- Alphabetical ordering of the functions of the specific_analyses.relax_disp.disp_data module.
- Created the specific_analyses.relax_disp.disp_data.loop_all_data() function. This is to loop over all possible base relaxation dispersion data (spectrometer frequencies then dispersion points).
- Updates for the dispersion user functions for the changes in specific_fns.relax_disp.
- Typo fix in the new loop_all_data() function.
- Created the lib.dispersion.calc_two_point_r2eff() function. This is for calculating the R2eff/R1rho value for the fixed relaxation time data.
- Improvements to the specific_analysis.relax_disp.disp_data module. The function loop_all_data() has been expanded to include the relaxation time period into the loop. The functions return_intensity() and return_key() have been added to return peak intensities and the key corresponding to the data returned by loop_all_data().
- Fixes for some latent bugs in the specific_analyses.relax_disp.disp_data module. The checks for the CPMG-data type in a number of functions now uses the CPMG_EXP list instead of fixed strings.
- Completed the relaxation dispersion calculate() method. This allows the R2eff/R1rho values to be calculated for the fixed relaxation time period experiments through the calc user function.
- Created a script for running a full relaxation dispersion analysis on Flemming Hansen's data. This is located in the shared data directories and is not part of the test suite as a full analysis will take far too long.
- Updated the models in the script for the full relaxation dispersion analysis of Hansen's data.
- Updated the backend of the relax_disp.select_model to handle the new model names.
- Spun out a number of dispersion methods into the new specific_analyses.relax_disp.parameters module. This is a module of functions relating to the parameters of the relaxation dispersion models.
- More spacing before the sectioning printouts in the relaxation dispersion auto-analysis.
- Modified the printouts of the relax_disp.select_model user function.
- Fix for the relaxation dispersion auto-analysis. The data pipes created for each model optimised are now switched to prior to any operations on the pipe.
- Changed the phi_ex parameter in the LM63 model back to rex.
- Changed the Grace string for the rex parameter to be phi_ex.
- Converted all of the specific_analyses.relax_disp.parameters module to handle different models. The R2eff and I0 parameters are now only part of the 'R2eff' model and all other standard parameters belong to all of the other models.
- Shifted all of the constant relaxation dispersion variables into the specific module. All of the dispersion code now uses the variables of specific_analyses.relax_disp.variables.
- Renamed the lib.dispersion.equations.fast_2site() function to r2eff_LM63(). The number of relaxation times has also been replaced by the number of dispersion points.
- Added the return_cpmg_frqs() and return_spin_lock_nu1() functions to specific_analyses.relax_disp.disp_data.
- Updates to the relaxation dispersion auto-analysis. The Grace plots created are now more dependent on the current model, so that dispersion curves are only created for the 'R2eff' model. The specific_analyses.relax_disp.variables module is now also being used.
- Started to redesign the relaxation dispersion target function class. The input data is now expected to be R2eff/R1rho data and all mentions of exponential curves have been eliminated. The func_exp_fit() target function has been deleted as it is not used - as now the _minimise_r2eff() method in the dispersion specific analysis class is used instead. And the func_fast_2site() target function has been renamed to func_LM63().
- Redesigned the optimisation code of the dispersion analysis specific class for the new target functions. This includes the assembling of R2eff/R1rho values instead of peak heights, and a number of small fixes.
- Shifted the LM63 dispersion model functions into the new lib.dispersion.lm63 module.
- The reference spectrum is now not included when counting the number of dispersion points.
- Fix for the lib.dispersion.lm63 module and parameters of zero are now gracefully handled.
- Fixes for the func_LM63() dispersion target function.
- Shifted the R2eff/R1rho value and error assembly into specific_analyses.relax_disp.disp_data. This is in the new return_r2eff_arrays() function. The code has also been debugged and made functional.
- Added support for handling missing data in the relaxation dispersion analysis. This support was mentioned in the post http://thread.gmane.org/gmane.science.nmr.relax.devel/3835.
- Added a FIXME to a comment about the hardcoded Bootstrap number for relaxation dispersion.
- Started to add support for Monte Carlo simulations for the relaxation dispersion models. This is for all models except 'R2eff'. The changes are extensive but incomplete. The new functions disp_point_key_from_index() and disp_point_index_from_key() have been added to the specific_analyses.relax_disp.disp_data module, but the disp_point_index_from_key() function still needs work. The _back_calc() method of the specific_analyses.relax_disp.Relax_disp class has been redesigned, as well as base_data_loop() method and all methods which depend on it.
- Updated the relaxation dispersion system tests of the Hansen CPMG data for the new models. The models are now 'LM63' and 'CR72', and the tests have been renamed to Relax_disp.test_hansen_cpmg_data_LM63 and Relax_disp.test_hansen_cpmg_data_CR72.
- Update of the specific_analyses.relax_disp package docstring.
- Fix for the linear constraints setup of the 'R2eff' relaxation dispersion model. There are no constraints, so the specific_analyses.relax_disp.parameters.linear_constraints() function now returns A and b values of None.
- Basic fix for the _back_calc_r2eff() relaxation dispersion method. A variable was misnamed.
- Major redesign of the relaxation dispersion data model in the relax data store. The data model now revolves around the three concepts of the spectrometer frequency, the dispersion points, and the relaxation times. Peak intensity data is now handled through averaging using the new specific_analyses.relax_disp.disp_data.average_intensity() function. R2eff/R1rho values are now referenced by a key generated from the spectrometer frequency and nu_CPMG frequency or nu1 spin-lock field strength. All of the specific_analyses.relax_disp package has been standardised around these concepts. This simplifies all of the modules of the package and removes a large number of latent bugs.
- A number of fixes to partly enable Monte Carlo simulations for the non 'R2eff' dispersion models.
- Finally Monte Carlo simulations for the relaxation dispersion models now work. This was a simple fix for the specific_analyses.relax_disp.parameters.param_index_to_param_info() function.
- Created truncated data files of the Hansen CPMG data. This consists of residues 70 and 71 and will be used to massively speed up the system tests.
- The truncated Hansen CPMG data is now in the form of Sparky peak lists.
- Now all of the Hansen CPMG data is present as truncated Sparky peak lists.
- Speedup for the relaxation dispersion system tests which use Flemming Hansen's CPMG data. The system test script now reads the truncated data files (of only residues 70 and 71) to minimise the time required to read the data and store it in the relax data store.
- Added a script to the test suite shared data for analysing the truncated Hansen CPMG data.
- Fixes for the LM63 dispersion CPMG model. The 'r2' model parameter is now an array as there is one R2 value per magnetic field strength. And the 'rex' parameter has been renamed to 'phi_ex' and is scaled quadratically with the field strength within the optimisation target function.
- Fix for the setup of the relaxation dispersion GUI analysis. The base method add_execute_relax() has been renamed to add_execute_analysis().
- Added support for interfacing with Art Palmer's CPMGFit program. The two new user functions relax_disp.cpmgfit_input and relax_disp.cpmgfit_execute have been created to interface with CPMGFit. The first creates the per spin system CPMGFit input files as well as a batch script for executing CPMGFit with all the input files. The second bypasses the batch script and allows CPMGFit to be executed from within relax. This mimics the palmer and dasha user functions. The back end code is in the new specific_analyses.relax_disp.cpmgfit module.
- Created the Relax_disp.test_hansen_cpmgfit_input system test. This is for checking the operation of the relax_disp.cpmgfit_input user function conversion of Flemming Hansen's CPMG R2eff values into input files for CPMGFit. A relax state file containing the results of an analysis of an 'R2eff' model analysis of the truncated data has been added to the test suite data to speed up the test and to check the loading of dispersion state files.
- Created a directory for the results of the CPMGFit program using Hansen's truncated CPMG data. The script 'cpmgfit.py' has been added to create the input files for CPMGFit and execute the program. The input and batch files have been added to the repository as well.
- Added the results from NESSY of the analysis of Flemming Hansen's truncated CPMG data. This is only for the truncated data of residues 70 and 71. All files, except for the PNG graphics, have been added to the repository. The 'summary' file has been created to hold the data from NESSY's summary tab, as this is not stored in the NESSY saved state and is permanently lost after closing NESSY.
- A dispersion saved state from the prompt or script UI can now be associated with a GUI analysis.
- Created the Relax_disp.test_hansen_trunc_data GUI test for checking the GUI dispersion auto-analysis. This checks the full operation of the relaxation dispersion GUI analysis, without checking the final results (to be added later).
- Fixes for the change to the new spectrometer.frequency user function and associated data structures.
- Removed the preview button from the file selection GUI element of the CPMGFit user functions. These are the relax_disp.cpmgfit_execute and relax_disp.cpmgfit_input user functions.
- The relaxation dispersion specific code now uses the changes of the spectrometer.frequency user function. This simplifies the handling of magnetic field strength data.
- More fixes to the relax_disp branch for the changes of the spectrometer.frequency user function.
- Changes to the CPMGFit input files due to the new spectrometer.frequency user function.
- The relax_disp.cpmgfit_execute user function now correctly calls CPMGFit. The -grid command line option has been added and the output for each spin is sent to a special output file.
- Updated the input files and added the output files for the CPMGFit program with Hansen's CPMG data. This is for the data truncated to residues 70 and 71.
- Fixes for the relax_disp branch for the spectrometer.frequency user function changes.
- Fix for the Relax_disp.test_hansen_cpmgfit_input system test. This is for the recent spectrometer.frequency user function changes.
- The specific_analyses.relax_disp.disp_data.loop_frq() function can now handle missing data. This allows the loop to yield a single value of None when the spectrometer information has not been loaded and enables R1rho analyses at a single field strength.
- Fix for the LM63 dispersion model target function - the scaled Phi_ex value is now used for the R2.
- Fixes for the relaxation dispersion auto-analysis for the LM63 model. The Rex parameter is now the phi_ex parameter.
- Added printouts of the optimised parameters to the Relax_disp.test_hansen_cpmg_data_LM63 system test. This includes the conversion to the equivalent CPMGFit parameters.
- Massively increased the precision of the R2eff error analysis. The hard-coded simulation number variable is now set to 100000. This appears to be necessary for reliably reproducing results in the subsequent dispersion models.
- Created the specific_analyses.relax_disp.disp_data.spin_has_frq_data() function. This is for determining if a spin has peak intensity for the given spectrometer field strength.
- Updates some scripts for the spectrometer.frequency user function change.
- Created a script to calculate the R2eff rate errors extremely precisely for Hansen's CPMG data. This uses 1 million Bootstrap simulations for calculating the errors. The 'r2eff_values.bz2' is saved after deleting the spin specific r2eff_sim structures so that the file drops from 388 Mb in size to 7.3 kb.
- The CPMGFit script for Hansen's CPMG data now starts with the high precision error r2eff_values.bz2 file. This ensures consistency between comparisons between relax, NESSY, CPMGFit, etc.
- Removed the '_trunc' part of the nessy_results directory from the NESSY final save file.
- The relaxation dispersion loop_point() function can now return the reference point. This is enabled via the skip_ref argument.
- Created the relax_disp.nessy_input user function front and backends. This user function takes the data in the relax data store and creates a NESSY save file to be opened within NESSY. The backend is the new specific_analyses.relax_disp.nessy module. For the GUI frontend, graphics for icons and the wizard have been taken from the NESSY repository file pics/nessy_new.png@r1088 in the trunk.
- A script has been added to create the NESSY input for Flemming Hansen's CPMG data.
- Updated the NESSY results for Flemming Hansen's CPMG data for the R2eff values with high precision errors. A file containing the log or printouts from NESSY has been added for reference.
- Updated the NESSY log from the Hansen CPMG data of residue 70 to remove the NESSY errors. These were removed with the commit r1090 to the NESSY trunk.
- Split up the r2eff_values.bz2 save file into the results files for each data pipe. This is for Flemming Hansen's CPMG data truncated to residues 70 and 71. This is to simplify the system tests which use this data.
- Large simplification of the Relax_disp system tests using Hansen's CPMG data. Instead of calculating the R2eff values in the test, these are read from the high error precision results files in test_suite/shared_data/dispersion/Hansen. This allows the model parameters to be consistently found and to be identical between different runs of the test.
- Added a file which compares the results for the LM63 model with Hansen's CPMG data between all programs. This currently includes relax, NESSY and CPMGFit.
- Added a printout to the specific_analyses.relax_disp.cpmgfit.translate_model() function.
- The dispersion system test script for Hansen's CPMG data can now run stand-alone.
- The log barrier constraint algorithm is now used for the relaxation dispersion optimisation. This is to allow constraints in the absence of gradient target functions. The constraints have been turned on by default in the auto-analysis.
- Changed the dispersion GUI tab to use the model names from specific_analyses.relax_disp.variables.
- The spectrum wizard now uses the spectrometer.frequency user function rather than frq.set. The frq.set user function is now called spectrometer.frequency.
- An upper limit of 200 rad/s has been added to the linear constraints for the R2 dispersion parameters.
- Fixes for the checking in the Relax_disp.test_hansen_cpmgfit_input system test.
- The relaxation dispersion auto-analysis now calls the relax_disp.plot_disp_curves user function. This user function is not implemented yet, but will be used to create plots of the dispersion curves.
- Implemented a basic graph for the relax_disp.plot_disp_curves user function. This simply plots out the nu_CPMG value or spin-lock field verses the R2eff/R1rho values from the experiment. The graph of the back calculated R2eff/R1rho values from the model fit is still to be added.
- Fix for the linear constraints for the 'R2eff' model. The A and b matrices are no longer set to None, as this kills the auto-analysis or any analysis when constraints are turned on. Now the constraints 0 <= R2eff <= 200 and I0 >= 0 are used.
- Fixes for the peak intensity loading wizard for the frq.set to spectrometer.frequency user function change.
- Fixes for the backend of the relax_disp.plot_exp_curves user function. This code needed to be updated for the major changes in the relax_disp branch.
- Fixes for the checks in the Relax_disp.test_exp_fit system test. The r2eff and i0 spin data structure keys are now strings.
- Two class variables have been added to the dispersion auto-analysis for fast optimisation. This includes variables for the function tolerance and maximum number of iterations, and matches those of the model-free auto-analysis of the dauvergne_protocol module. These will be used to speed up the test suite.
- Speed up of the system tests using Flemming Hansen's CPMG data. The grid search increments, function tolerance and maximum number of iterations have all been made looser.
- Added parameter checks to the Relax_disp.test_hansen_cpmg_data_LM63 system test.
- Fix for the phi_ex dispersion parameter scaling - the scaling was in the wrong direction.
- Added a directory of relax results for the truncated high-precision Hansen CPMG R2eff values. This uses the base_pipe.bz2 and r2eff_pipe.bz2 files with the high-precision R2eff errors, and hence can be compared to the NESSY and CPMGFit results.
- Added the residue :71 results to the lm63_comparison file. This is a summary of the optimisation results using the high-precision R2eff error results for the different dispersion softwares.
- Changes to the dispersion auto-analysis write_results() method. This is to output more of the dispersion parameters to text files and 2D grace plots.
- Created a directory and script in preparation for the relax_disp.sherekhan_input user function.
- Created the relax_disp.sherekhan_input user function. This includes an icon for the GUI, and the full front and backends.
- Added a wizard graphic for the relax_disp.sherekhan_input user function.
- Shifted the core of the model_loop() dispersion method into its own function. The new function specific_analyses.relax_disp.disp_data.loop_cluster() can now be used by other parts of relax. The model_loop() method now yields the data that loop_cluster() yields.
- Redesign of the relax_disp.sherekhan_input user function to handle spin clustering.
- Added the ShereKhan results for the high-precision R2eff data for Hansen's CPMG data.
- Converted the readme file for Flemming Hansen's CPMG data directory to uppercase.
- Updated the LM63 model comparison table.
- Modified the dispersion calculate() method for the R2eff values to use the analytic equation. For the R2eff/R1rho values calculated for the fixed time period dispersion experiments via the calc user function, the very slow and tedious bootstrapping approach has been replaced by the very quick direct error calculation. The two techniques produce the same results as the bootstrap simulation number approaches infinity.
- Bug fix for the peak intensity error analysis in the dispersion auto-analysis. Now the error analysis is split based on the magnetic field strength. Previously the analysis was a mess with the split often being individual spectra.
- The proper experiment type is now set for the Relax_disp.test_hansen_trunc_data GUI test.
- Updated the relax_disp.exp_type user function to be more specific an include more experiment types.
- Updated the specific_analyses.relax_disp.variables module for the relax_disp.exp_type changes.
- The relax_disp.relax_time page is now always shown in the peak intensity wizard for the dispersion GUI. This number is needed for the fixed time period experiments as well to calculated the R2eff/R1rho values and errors.
- Fix for the dispersi

### Comments: