relax SVN archive

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.

Reverted r23252 as this uses far, far too much RAM, and there is a better solution.

The command used was:
svn merge -r23252:r23251 .

.....
r23252 | bugman | 2014-05-20 11:48:11 +0200 (Tue, 20 May 2014) | 7 lines
Changed paths:
M /branches/frame_order_cleanup/test_suite/shared_data/frame_order/cam/generate_base.py

Large increase in accuracy of the RDC and PCS averaging.

This is for the CaM frame order test data generation base script. By storing the RDCs and PCSs in
numpy.float128 arrays, a 64-bit system is required, and then using numpy.average(), the average
value can be calculated with a much higher accuracy. As N becomes larger, the averaging introduces
greater and greater amounts of truncation artifacts. So this change alleviates this. However a lot
more RAM is now required.
.....

Merged revisions 23254 via svnmerge from
svn+ssh://bugman@.../svn/relax/trunk

........
r23254 | bugman | 2014-05-20 13:37:32 +0200 (Tue, 20 May 2014) | 12 lines

Fix for the chain-reaction failures in the test suite.

This fixes bug #22055 (https://gna.org/bugs/?22055), the processor.run_queue() not cleaning up in
uni_processor - chain-reaction failures in the test suite.

The fix was insanely simple, just implementing what was mentioned Gary's FIXME comment in the
run_queue() method of the uni-processor object. The queue execution code has been placed inside a
'try' statement and the queue cleaning up code in a 'finally' statement.

This closes a painfully difficult to find bug that has been in relax since 2006.
........

Fix for the chain-reaction failures in the test suite.

This fixes bug #22055 (https://gna.org/bugs/?22055), the processor.run_queue() not cleaning up in
uni_processor - chain-reaction failures in the test suite.

The fix was insanely simple, just implementing what was mentioned Gary's FIXME comment in the
run_queue() method of the uni-processor object. The queue execution code has been placed inside a
'try' statement and the queue cleaning up code in a 'finally' statement.

This closes a painfully difficult to find bug that has been in relax since 2006.

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.

Large increase in accuracy of the RDC and PCS averaging.

This is for the CaM frame order test data generation base script. By storing the RDCs and PCSs in
numpy.float128 arrays, a 64-bit system is required, and then using numpy.average(), the average
value can be calculated with a much higher accuracy. As N becomes larger, the averaging introduces
greater and greater amounts of truncation artifacts. So this change alleviates this. However a lot
more RAM is now required.

Complete redesign of the CaM frame order data generation base script for speed and memory savings.

Although the rotated XH bond vector and atomic position code was very fast, the amount of memory
needed to store these in the spin containers and interatomic data containers was huge when N > 1e6.
The subsequent rdc.back_calc and pcs.back_calc user function calls would also take far too long.

Therefore the base script has been redesigned. The _create_distribution() method has been split
into four: _calculate_pcs(), _calculate_rdc(), _create_distribution(), and _pipe_setup().
The _pipe_setup() method is called first to set up the data pipe with all required data. Then the
_calculate_rdc() and _calculate_pcs() methods, and finally _create_distribution() if the DIST_PDB
flag is set.

The calls to the rdc.back_calc and pcs.back_calc user functions have been eliminated. Instead the
_calculate_rdc() and _calculate_pcs() methods calculate the averaged RDC and PCS themselves as numpy
array structures. Rather than storing the huge rotated vectors and atomic positions data
structures, the RDCs and PCSs are summed. These are then divided by self.N at the end to average
the values.

Compared to the old code, when N is set to 20 million the RAM usage drops from ~20 GB to ~65 MB.
The total run time is also decreased on one system from a few days to a few hours (an order or two
of magnitude).

Fix for variable num_points not set.

An attempt to fix the pipe_control/minimisy.py minimise() call to processor.run_queue().

It was thought that I was modifying the address of array class(back_calc).
But this does not seem to be the problem.

Turned of processor.run_queue() when using calc().

task #7793: (https://gna.org/task/?7793) Speed-up of dispersion models.

A weird behaviour was found when running the test-suite.

Somehow, queued jobs from the last test suite was not flushed and done.
Running the test-suite gave errors on almost all tests.

Inspecting systemtest which only used calc() for the dispersion API, showed that no jobs was queued
in the calculate() method, and the call to processor.run_queue(), was turned off, solving the problem.