Source Code for Module test_suite.system_tests.align_tensor

  1  ############################################################################### 
  2  #                                                                             # 
  3  # Copyright (C) 2006-2010,2012,2014-2015 Edward d'Auvergne                    # 
  4  # Copyright (C) 2008 Sebastien Morin                                          # 
  5  #                                                                             # 
  6  # This file is part of the program relax (http://www.nmr-relax.com).          # 
  7  #                                                                             # 
  8  # This program is free software: you can redistribute it and/or modify        # 
  9  # it under the terms of the GNU General Public License as published by        # 
 10  # the Free Software Foundation, either version 3 of the License, or           # 
 11  # (at your option) any later version.                                         # 
 12  #                                                                             # 
 13  # This program is distributed in the hope that it will be useful,             # 
 14  # but WITHOUT ANY WARRANTY; without even the implied warranty of              # 
 15  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               # 
 16  # GNU General Public License for more details.                                # 
 17  #                                                                             # 
 18  # You should have received a copy of the GNU General Public License           # 
 19  # along with this program.  If not, see <http://www.gnu.org/licenses/>.       # 
 20  #                                                                             # 
 21  ############################################################################### 
 22   
 23  # Python module imports. 
 24  from copy import deepcopy 
 25  from tempfile import mkstemp 
 26   
 27  # relax module imports. 
 28  from data_store import Relax_data_store; ds = Relax_data_store() 
 29  from test_suite.system_tests.base_classes import SystemTestCase 
 30   
 31   
 32 -class Align_tensor(SystemTestCase): 
 33      """Class for testing various aspects specific to the alignment tensors.""" 
 34   
 35 -    def setUp(self): 
 36          """Function for initialising a few alignment tensors.""" 
 37   
 38          # Create a data pipe. 
 39          self.interpreter.pipe.create('test', 'N-state') 
 40   
 41          # Temp file name. 
 42          ds.tmpfile_handle, ds.tmpfile = mkstemp() 
 43   
 44          # The alignment. 
 45          align_id = 'test' 
 46   
 47          # Tensor name lists. 
 48          self.full_list = ['0 full', '1 full', '2 full', '3 full', '4 full'] 
 49          self.red_list = ['0 red', '1 red', '2 red', '3 red', '4 red'] 
 50   
 51          # Error. 
 52          error = 1.47411211147e-05 
 53   
 54          # Tensor lists. 
 55          self.tensors_full = [ 
 56                  (0.00014221982216882766, -0.00014454300156652134, -0.00070779621164871397, -0.00060161949408277324, 0.00020200800707295083), 
 57                  (-0.00014307694949297205, -0.00039671919293883539, -0.00024724524395487659, 0.00031948292975139144, 0.00018868359624777637), 
 58                  (-0.00022967898444150887, -0.00027171643813494106, -0.00021961563147411279, 0.00010337393266477703, 0.00029030226175831515), 
 59                  (0.00043690692358615301, -0.00034379559287467062, -0.00019359695171683388, 0.00030194133983804048, -6.314162250164486e-05), 
 60                  (-0.00026249527958822807, 0.00073561736796410628, 6.3975419225898133e-05, 6.2788017118057252e-05, 0.00020119758245770023) 
 61          ] 
 62          self.tensors_red = [ 
 63                  (-0.0004037026160192775, 0.00023172423501111316, -0.00020915186581478394, -0.00028817367472760139, -8.7172337025481604e-05), 
 64                  (0.0003767999506688964, -0.00021492227011444111, 0.00019620694392616774, 0.00027163215478635274, 8.147201253457049e-05), 
 65                  (0.00025970120925482461, -0.00014782823602910519, 0.00013565269563569894, 0.00018741173517420359, 5.6252903270026344e-05), 
 66                  (0.00014574884684542708, -8.3162940224598374e-05, 7.4927100277784987e-05, 0.00010508245294401461, 3.1156238348722986e-05), 
 67                  (-0.00011267453337899962, 6.412308037476237e-05, -5.7897942333203444e-05, -8.1865863377039068e-05, -2.5273427585025123e-05) 
 68          ] 
 69   
 70          # Define the domains. 
 71          self.interpreter.domain(id='full') 
 72          self.interpreter.domain(id='red') 
 73   
 74          # Set up the tensors. 
 75          for i in range(5): 
 76              # Load the tensor. 
 77              self.interpreter.align_tensor.init(tensor=self.full_list[i], align_id=align_id, params=self.tensors_full[i], param_types=0) 
 78              self.interpreter.align_tensor.init(tensor=self.red_list[i], align_id=align_id, params=self.tensors_red[i], param_types=0) 
 79   
 80              # Errors. 
 81              self.interpreter.align_tensor.init(tensor=self.full_list[i], align_id=align_id, params=(error, error, error, error, error), param_types=0, errors=True) 
 82              self.interpreter.align_tensor.init(tensor=self.red_list[i], align_id=align_id, params=(error, error, error, error, error), param_types=0, errors=True) 
 83   
 84              # Domain. 
 85              self.interpreter.align_tensor.set_domain(tensor=self.full_list[i], domain='full') 
 86              self.interpreter.align_tensor.set_domain(tensor=self.red_list[i], domain='red') 
 87   
 88              # Tensor reductions. 
 89              self.interpreter.align_tensor.reduction(full_tensor=self.full_list[i], red_tensor=self.red_list[i]) 
 90   
 91          # Reset some values. 
 92          cdp.align_tensors[2].set(param='Axx', value=1) 
 93   
 94   
 95 -    def test_align_tensor_matrix_angles(self): 
 96          """Test the operation of the align_tensor.matrix_angles user function for different basis sets. 
 97   
 98          This originates from the script in test_suite/shared_data/align_data/basis_sets/. 
 99          """ 
100   
101          # Random tensors of {Axx, Ayy, Axy, Axz, Ayz} generated using random.uniform(0, 1e-4). 
102          tensor1 = [5.4839183673166663e-05, 3.692459844061351e-05, 1.994164790083226e-05, 4.5945264935308495e-05, 1.0090119622465559e-05] 
103          tensor2 = [1.5832157768761617e-05, -4.9797877146095514e-05, -3.6007226809999e-05, -3.8175058915299295e-05, 5.3131759988544946e-05] 
104          tensor3 = [3.892445496049645e-05, -1.7165585393754253e-05, 7.803231512226243e-05, -3.057296854986567e-05, 9.31348723610886e-05] 
105          tensor4 = [4.6720247808382186e-05, -9.140580842599e-05, -3.415945182796103e-05, -1.7753928806205142e-05, 5.20457038882803e-05] 
106   
107          # Create a N-state analysis data pipe. 
108          self.interpreter.pipe.create('basis set comparison', 'N-state') 
109   
110          # Load the tensors. 
111          self.interpreter.align_tensor.init(tensor='t1', align_id='t1', params=tuple(tensor1)) 
112          self.interpreter.align_tensor.init(tensor='t2', align_id='t2', params=tuple(tensor2)) 
113          self.interpreter.align_tensor.init(tensor='t3', align_id='t3', params=tuple(tensor3)) 
114          self.interpreter.align_tensor.init(tensor='t4', align_id='t4', params=tuple(tensor4)) 
115   
116          # Display. 
117          self.interpreter.align_tensor.display() 
118   
119          # The standard inter-matrix angles. 
120          self.interpreter.align_tensor.matrix_angles(basis_set='matrix') 
121          self.assertAlmostEqual(cdp.align_tensors.angles[0, 0], 0.000000000000000) 
122          self.assertAlmostEqual(cdp.align_tensors.angles[0, 1], 2.075565413247085) 
123          self.assertAlmostEqual(cdp.align_tensors.angles[0, 2], 1.338099052806276) 
124          self.assertAlmostEqual(cdp.align_tensors.angles[0, 3], 1.931864731843497) 
125          self.assertAlmostEqual(cdp.align_tensors.angles[1, 0], 2.075565413247085) 
126          self.assertAlmostEqual(cdp.align_tensors.angles[1, 1], 0.000000000000000) 
127          self.assertAlmostEqual(cdp.align_tensors.angles[1, 2], 1.238391416802885) 
128          self.assertAlmostEqual(cdp.align_tensors.angles[1, 3], 0.425283739619488) 
129          self.assertAlmostEqual(cdp.align_tensors.angles[2, 0], 1.338099052806276) 
130          self.assertAlmostEqual(cdp.align_tensors.angles[2, 1], 1.238391416802885) 
131          self.assertAlmostEqual(cdp.align_tensors.angles[2, 2], 0.000000000000000) 
132          self.assertAlmostEqual(cdp.align_tensors.angles[2, 3], 1.269973710252322) 
133          self.assertAlmostEqual(cdp.align_tensors.angles[3, 0], 1.931864731843497) 
134          self.assertAlmostEqual(cdp.align_tensors.angles[3, 1], 0.425283739619488) 
135          self.assertAlmostEqual(cdp.align_tensors.angles[3, 2], 1.269973710252322) 
136          self.assertAlmostEqual(cdp.align_tensors.angles[3, 3], 0.000000014901161) 
137   
138          # The inter-tensor vector angles for the irreducible 5D basis set {A-2, A-1, A0, A1, A2}. 
139          self.interpreter.align_tensor.matrix_angles(basis_set='irreducible 5D') 
140          self.assertAlmostEqual(cdp.align_tensors.angles[0, 0], 0.000000000000000) 
141          self.assertAlmostEqual(cdp.align_tensors.angles[0, 1], 2.075565413247085) 
142          self.assertAlmostEqual(cdp.align_tensors.angles[0, 2], 1.338099052806276) 
143          self.assertAlmostEqual(cdp.align_tensors.angles[0, 3], 1.931864731843497) 
144          self.assertAlmostEqual(cdp.align_tensors.angles[1, 0], 2.075565413247085) 
145          self.assertAlmostEqual(cdp.align_tensors.angles[1, 1], 0.000000000000000) 
146          self.assertAlmostEqual(cdp.align_tensors.angles[1, 2], 1.238391416802885) 
147          self.assertAlmostEqual(cdp.align_tensors.angles[1, 3], 0.425283739619488) 
148          self.assertAlmostEqual(cdp.align_tensors.angles[2, 0], 1.338099052806276) 
149          self.assertAlmostEqual(cdp.align_tensors.angles[2, 1], 1.238391416802885) 
150          self.assertAlmostEqual(cdp.align_tensors.angles[2, 2], 0.000000021073424) 
151          self.assertAlmostEqual(cdp.align_tensors.angles[2, 3], 1.269973710252322) 
152          self.assertAlmostEqual(cdp.align_tensors.angles[3, 0], 1.931864731843497) 
153          self.assertAlmostEqual(cdp.align_tensors.angles[3, 1], 0.425283739619488) 
154          self.assertAlmostEqual(cdp.align_tensors.angles[3, 2], 1.269973710252322) 
155          self.assertAlmostEqual(cdp.align_tensors.angles[3, 3], 0.000000021073424) 
156   
157          # The inter-tensor vector angles for the unitary 9D basis set {Sxx, Sxy, Sxz, Syx, Syy, Syz, Szx, Szy, Szz}. 
158          self.interpreter.align_tensor.matrix_angles(basis_set='unitary 9D') 
159          self.assertAlmostEqual(cdp.align_tensors.angles[0, 0], 0.000000000000000) 
160          self.assertAlmostEqual(cdp.align_tensors.angles[0, 1], 2.075565413247085) 
161          self.assertAlmostEqual(cdp.align_tensors.angles[0, 2], 1.338099052806276) 
162          self.assertAlmostEqual(cdp.align_tensors.angles[0, 3], 1.931864731843497) 
163          self.assertAlmostEqual(cdp.align_tensors.angles[1, 0], 2.075565413247085) 
164          self.assertAlmostEqual(cdp.align_tensors.angles[1, 1], 0.000000014901161) 
165          self.assertAlmostEqual(cdp.align_tensors.angles[1, 2], 1.238391416802885) 
166          self.assertAlmostEqual(cdp.align_tensors.angles[1, 3], 0.425283739619488) 
167          self.assertAlmostEqual(cdp.align_tensors.angles[2, 0], 1.338099052806276) 
168          self.assertAlmostEqual(cdp.align_tensors.angles[2, 1], 1.238391416802885) 
169          self.assertAlmostEqual(cdp.align_tensors.angles[2, 2], 0.000000000000000) 
170          self.assertAlmostEqual(cdp.align_tensors.angles[2, 3], 1.269973710252322) 
171          self.assertAlmostEqual(cdp.align_tensors.angles[3, 0], 1.931864731843497) 
172          self.assertAlmostEqual(cdp.align_tensors.angles[3, 1], 0.425283739619488) 
173          self.assertAlmostEqual(cdp.align_tensors.angles[3, 2], 1.269973710252322) 
174          self.assertAlmostEqual(cdp.align_tensors.angles[3, 3], 0.000000014901161) 
175   
176          # The inter-tensor vector angles for the unitary 5D basis set {Sxx, Syy, Sxy, Sxz, Syz}. 
177          self.interpreter.align_tensor.matrix_angles(basis_set='unitary 5D') 
178          self.assertAlmostEqual(cdp.align_tensors.angles[0, 0], 0.000000000000000) 
179          self.assertAlmostEqual(cdp.align_tensors.angles[0, 1], 1.962377927826435) 
180          self.assertAlmostEqual(cdp.align_tensors.angles[0, 2], 1.334149185082829) 
181          self.assertAlmostEqual(cdp.align_tensors.angles[0, 3], 1.747728360218234) 
182          self.assertAlmostEqual(cdp.align_tensors.angles[1, 0], 1.962377927826435) 
183          self.assertAlmostEqual(cdp.align_tensors.angles[1, 1], 0.000000000000000) 
184          self.assertAlmostEqual(cdp.align_tensors.angles[1, 2], 1.163535022090889) 
185          self.assertAlmostEqual(cdp.align_tensors.angles[1, 3], 0.449110033170688) 
186          self.assertAlmostEqual(cdp.align_tensors.angles[2, 0], 1.334149185082829) 
187          self.assertAlmostEqual(cdp.align_tensors.angles[2, 1], 1.163535022090889) 
188          self.assertAlmostEqual(cdp.align_tensors.angles[2, 2], 0.000000000000000) 
189          self.assertAlmostEqual(cdp.align_tensors.angles[2, 3], 1.180324869602255) 
190          self.assertAlmostEqual(cdp.align_tensors.angles[3, 0], 1.747728360218234) 
191          self.assertAlmostEqual(cdp.align_tensors.angles[3, 1], 0.449110033170688) 
192          self.assertAlmostEqual(cdp.align_tensors.angles[3, 2], 1.180324869602255) 
193          self.assertAlmostEqual(cdp.align_tensors.angles[3, 3], 0.000000000000000) 
194   
195          # The inter-tensor vector angles for the geometric 5D basis set {Szz, Sxxyy, Sxy, Sxz, Syz}. 
196          self.interpreter.align_tensor.matrix_angles(basis_set='geometric 5D') 
197          self.assertAlmostEqual(cdp.align_tensors.angles[0, 0], 0.000000000000000) 
198          self.assertAlmostEqual(cdp.align_tensors.angles[0, 1], 1.924475705542377) 
199          self.assertAlmostEqual(cdp.align_tensors.angles[0, 2], 1.290778333130633) 
200          self.assertAlmostEqual(cdp.align_tensors.angles[0, 3], 1.724794814547786) 
201          self.assertAlmostEqual(cdp.align_tensors.angles[1, 0], 1.924475705542377) 
202          self.assertAlmostEqual(cdp.align_tensors.angles[1, 1], 0.000000021073424) 
203          self.assertAlmostEqual(cdp.align_tensors.angles[1, 2], 1.128650397698967) 
204          self.assertAlmostEqual(cdp.align_tensors.angles[1, 3], 0.418891267835127) 
205          self.assertAlmostEqual(cdp.align_tensors.angles[2, 0], 1.290778333130633) 
206          self.assertAlmostEqual(cdp.align_tensors.angles[2, 1], 1.128650397698967) 
207          self.assertAlmostEqual(cdp.align_tensors.angles[2, 2], 0.000000000000000) 
208          self.assertAlmostEqual(cdp.align_tensors.angles[2, 3], 1.126308408980378) 
209          self.assertAlmostEqual(cdp.align_tensors.angles[3, 0], 1.724794814547786) 
210          self.assertAlmostEqual(cdp.align_tensors.angles[3, 1], 0.418891267835127) 
211          self.assertAlmostEqual(cdp.align_tensors.angles[3, 2], 1.126308408980378) 
212          self.assertAlmostEqual(cdp.align_tensors.angles[3, 3], 0.000000014901161) 
213   
214   
215 -    def test_align_tensor_svd(self): 
216          """Test the operation of the align_tensor.svd user function for different basis sets. 
217   
218          This originates from the script in test_suite/shared_data/align_data/basis_sets/. 
219          """ 
220   
221          # Random tensors of {Axx, Ayy, Axy, Axz, Ayz} generated using random.uniform(0, 1e-4). 
222          tensor1 = [5.4839183673166663e-05, 3.692459844061351e-05, 1.994164790083226e-05, 4.5945264935308495e-05, 1.0090119622465559e-05] 
223          tensor2 = [1.5832157768761617e-05, -4.9797877146095514e-05, -3.6007226809999e-05, -3.8175058915299295e-05, 5.3131759988544946e-05] 
224          tensor3 = [3.892445496049645e-05, -1.7165585393754253e-05, 7.803231512226243e-05, -3.057296854986567e-05, 9.31348723610886e-05] 
225          tensor4 = [4.6720247808382186e-05, -9.140580842599e-05, -3.415945182796103e-05, -1.7753928806205142e-05, 5.20457038882803e-05] 
226   
227          # Create a N-state analysis data pipe. 
228          self.interpreter.pipe.create('basis set comparison', 'N-state') 
229   
230          # Load the tensors. 
231          self.interpreter.align_tensor.init(tensor='t1', align_id='t1', params=tuple(tensor1)) 
232          self.interpreter.align_tensor.init(tensor='t2', align_id='t2', params=tuple(tensor2)) 
233          self.interpreter.align_tensor.init(tensor='t3', align_id='t3', params=tuple(tensor3)) 
234          self.interpreter.align_tensor.init(tensor='t4', align_id='t4', params=tuple(tensor4)) 
235   
236          # Display. 
237          self.interpreter.align_tensor.display() 
238   
239          # SVD for the irreducible 5D basis set {A-2, A-1, A0, A1, A2}. 
240          self.interpreter.align_tensor.svd(basis_set='irreducible 5D') 
241          self.assertAlmostEqual(cdp.align_tensors.cond_num, 6.131054731740254) 
242          self.assertAlmostEqual(cdp.align_tensors.singular_vals[0], 0.000413550754079) 
243          self.assertAlmostEqual(cdp.align_tensors.singular_vals[1], 0.000346772331066) 
244          self.assertAlmostEqual(cdp.align_tensors.singular_vals[2], 0.000185983409775) 
245          self.assertAlmostEqual(cdp.align_tensors.singular_vals[3], 0.000067451812481) 
246   
247          # SVD for the unitary 9D basis set {Sxx, Sxy, Sxz, Syx, Syy, Syz, Szx, Szy, Szz}. 
248          self.interpreter.align_tensor.svd(basis_set='unitary 9D') 
249          self.assertAlmostEqual(cdp.align_tensors.cond_num, 6.131054731740256) 
250          self.assertAlmostEqual(cdp.align_tensors.singular_vals[0], 0.000319487975056) 
251          self.assertAlmostEqual(cdp.align_tensors.singular_vals[1], 0.000267898410932) 
252          self.assertAlmostEqual(cdp.align_tensors.singular_vals[2], 0.000143681186401) 
253          self.assertAlmostEqual(cdp.align_tensors.singular_vals[3], 0.000052109790083) 
254   
255          # SVD for the unitary 5D basis set {Sxx, Syy, Sxy, Sxz, Syz}. 
256          self.interpreter.align_tensor.svd(basis_set='unitary 5D') 
257          self.assertAlmostEqual(cdp.align_tensors.cond_num, 6.503663323975970) 
258          self.assertAlmostEqual(cdp.align_tensors.singular_vals[0], 0.000250394766677) 
259          self.assertAlmostEqual(cdp.align_tensors.singular_vals[1], 0.000177094839440) 
260          self.assertAlmostEqual(cdp.align_tensors.singular_vals[2], 0.000106716235329) 
261          self.assertAlmostEqual(cdp.align_tensors.singular_vals[3], 0.000038500573324) 
262   
263          # SVD for the geometric 5D basis set {Szz, Sxxyy, Sxy, Sxz, Syz}. 
264          self.interpreter.align_tensor.svd(basis_set='geometric 5D') 
265          self.assertAlmostEqual(cdp.align_tensors.cond_num, 6.982475764795178) 
266          self.assertAlmostEqual(cdp.align_tensors.singular_vals[0], 0.000304033216708) 
267          self.assertAlmostEqual(cdp.align_tensors.singular_vals[1], 0.000201547771250) 
268          self.assertAlmostEqual(cdp.align_tensors.singular_vals[2], 0.000125447137629) 
269          self.assertAlmostEqual(cdp.align_tensors.singular_vals[3], 0.000043542323232) 
270   
271   
272 -    def test_copy(self): 
273          """Test the copying of alignment tensors (to catch U{bug #20338<https://web.archive.org/web/https://gna.org/bugs/?20338>}.""" 
274   
275          # First reset. 
276          self.interpreter.reset() 
277   
278          # Create a data pipe. 
279          self.interpreter.pipe.create('copy test', 'N-state') 
280   
281          # Initialise one tensor. 
282          self.interpreter.align_tensor.init(tensor='orig', align_id='test', params=self.tensors_full[0], param_types=0) 
283   
284          # Copy the tensor. 
285          self.interpreter.align_tensor.copy(tensor_from='orig', tensor_to='new') 
286   
287          # Checks. 
288          self.assertEqual(len(cdp.align_tensors), 2) 
289          self.assertEqual(cdp.align_tensors[0].name, 'orig') 
290          self.assertEqual(cdp.align_tensors[1].name, 'new') 
291   
292   
293 -    def test_copy_pipes(self): 
294          """Test the copying of alignment tensors between data pipes.""" 
295   
296          # First reset. 
297          self.interpreter.reset() 
298   
299          # Create two data pipes. 
300          self.interpreter.pipe.create('target', 'N-state') 
301          self.interpreter.pipe.create('source', 'N-state') 
302   
303          # Initialise one tensor. 
304          self.interpreter.align_tensor.init(tensor='orig', align_id='test', params=self.tensors_full[0], param_types=0) 
305   
306          # Copy the tensor. 
307          self.interpreter.align_tensor.copy(pipe_from='source', pipe_to='target') 
308   
309          # Checks. 
310          self.interpreter.pipe.switch('target') 
311          self.assertEqual(len(cdp.align_tensors), 1) 
312          self.assertEqual(cdp.align_tensors[0].name, 'orig') 
313   
314   
315 -    def test_copy_pipes_sims(self): 
316          """Test the copying of alignment tensor Monte Carlo simulations between data pipes.""" 
317   
318          # First reset. 
319          self.interpreter.reset() 
320   
321          # Create two data pipes. 
322          self.interpreter.pipe.create('target', 'N-state') 
323          self.interpreter.pipe.create('source', 'N-state') 
324   
325          # Initialise one tensor. 
326          self.interpreter.align_tensor.init(tensor='orig', align_id='test', params=self.tensors_full[0], param_types=0) 
327   
328          # Set up the number of simulations. 
329          sim_number = 10 
330          cdp.align_tensors[0].set_sim_num(sim_number) 
331   
332          # Initialise simulation tensors. 
333          for object_name in ['Axx', 'Ayy', 'Axy', 'Axz', 'Ayz']: 
334              for i in range(sim_number): 
335                  cdp.align_tensors[0].set(param=object_name, value=deepcopy(getattr(cdp.align_tensors[0], object_name)), category='sim', sim_index=i) 
336   
337          # Copy the tensor. 
338          self.interpreter.align_tensor.copy(pipe_from='source', pipe_to='target') 
339   
340          # Checks. 
341          self.interpreter.pipe.switch('target') 
342          self.assertEqual(len(cdp.align_tensors), 1) 
343          self.assertEqual(cdp.align_tensors[0].name, 'orig') 
344   
345   
346 -    def test_fix(self): 
347          """Test the align_tensor.fix user function.""" 
348   
349          # Fix all tensors. 
350          self.interpreter.align_tensor.fix() 
351   
352          # Unfix one tensor. 
353          self.interpreter.align_tensor.fix('2 full', fixed=False) 
354   
355          # Check the fixed flags. 
356          flags = [True]*10 
357          flags[4] = False 
358          for i in range(10): 
359              print("Checking the tensor %s: '%s'." % (i, cdp.align_tensors[i].name)) 
360              self.assertEqual(cdp.align_tensors[i].fixed, flags[i]) 
361   
362   
363 -    def test_to_and_from_xml(self): 
364          """Test the conversion to and from XML.""" 
365   
366          # Save the data pipe. 
367          self.interpreter.results.write(ds.tmpfile, dir=None, compress_type=0, force=True) 
368   
369          # Create a new data pipe. 
370          self.interpreter.pipe.create('new', 'N-state') 
371   
372          # Load the data. 
373          self.interpreter.results.read(ds.tmpfile, dir=None) 
374   
375          # Checks. 
376          self.assertEqual(len(cdp.align_tensors), 10) 
377          self.assert_(hasattr(cdp.align_tensors, 'reduction')) 
378          for i in range(5): 
379              # Full tensors. 
380              if i == 1: 
381                  self.assertAlmostEqual(cdp.align_tensors[i*2].Axx, 1.0) 
382              else: 
383                  self.assertAlmostEqual(cdp.align_tensors[i*2].Sxx, self.tensors_full[i][0]) 
384              self.assertAlmostEqual(cdp.align_tensors[i*2].Syy, self.tensors_full[i][1]) 
385              self.assertAlmostEqual(cdp.align_tensors[i*2].Sxy, self.tensors_full[i][2]) 
386              self.assertAlmostEqual(cdp.align_tensors[i*2].Sxz, self.tensors_full[i][3]) 
387              self.assertAlmostEqual(cdp.align_tensors[i*2].Syz, self.tensors_full[i][4]) 
388              self.assertEqual(cdp.align_tensors[i*2].name, self.full_list[i]) 
389   
390              # Reduced tensors. 
391              self.assertAlmostEqual(cdp.align_tensors[i*2+1].Sxx, self.tensors_red[i][0]) 
392              self.assertAlmostEqual(cdp.align_tensors[i*2+1].Syy, self.tensors_red[i][1]) 
393              self.assertAlmostEqual(cdp.align_tensors[i*2+1].Sxy, self.tensors_red[i][2]) 
394              self.assertAlmostEqual(cdp.align_tensors[i*2+1].Sxz, self.tensors_red[i][3]) 
395              self.assertAlmostEqual(cdp.align_tensors[i*2+1].Syz, self.tensors_red[i][4]) 
396              self.assertEqual(cdp.align_tensors[i*2+1].name, self.red_list[i]) 
397   
398              # Reduction. 
399              self.assertEqual(cdp.align_tensors.reduction[i], [i*2, i*2+1]) 
400