Source Code for Module test_suite.gui_tests.model_free

  1  ############################################################################### 
  2  #                                                                             # 
  3  # Copyright (C) 2006-2012 Edward d'Auvergne                                   # 
  4  #                                                                             # 
  5  # This file is part of the program relax (http://www.nmr-relax.com).          # 
  6  #                                                                             # 
  7  # This program is free software: you can redistribute it and/or modify        # 
  8  # it under the terms of the GNU General Public License as published by        # 
  9  # the Free Software Foundation, either version 3 of the License, or           # 
 10  # (at your option) any later version.                                         # 
 11  #                                                                             # 
 12  # This program is distributed in the hope that it will be useful,             # 
 13  # but WITHOUT ANY WARRANTY; without even the implied warranty of              # 
 14  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               # 
 15  # GNU General Public License for more details.                                # 
 16  #                                                                             # 
 17  # You should have received a copy of the GNU General Public License           # 
 18  # along with this program.  If not, see <http://www.gnu.org/licenses/>.       # 
 19  #                                                                             # 
 20  ############################################################################### 
 21   
 22  # Python module imports. 
 23  import numpy 
 24  from os import F_OK, access, sep 
 25  import wx 
 26   
 27  # relax module imports. 
 28  from data import Relax_data_store; ds = Relax_data_store() 
 29  from generic_fns.interatomic import interatomic_loop 
 30  from generic_fns.mol_res_spin import spin_loop 
 31  from generic_fns.pipes import cdp_name 
 32  from status import Status; status = Status() 
 33  from test_suite.gui_tests.base_classes import GuiTestCase 
 34   
 35  # relax GUI imports. 
 36  from gui.analyses import auto_model_free 
 37  from gui.interpreter import Interpreter; interpreter = Interpreter() 
 38  from gui.string_conv import float_to_gui, str_to_gui 
 39  from gui.uf_objects import Uf_storage; uf_store = Uf_storage() 
 40  from gui.wizard import Wiz_window 
 41   
 42   
 43 -class Mf(GuiTestCase): 
 44      """Class for testing various aspects specific to the model-free auto-analysis.""" 
 45   
 46 -    def test_mf_auto_analysis(self): 
 47          """Test the model-free auto-analysis.""" 
 48   
 49          # Simulate the new analysis wizard. 
 50          self.app.gui.analysis.menu_new(None) 
 51          page = self.app.gui.analysis.new_wizard.wizard.get_page(0) 
 52          page.select_mf(None) 
 53          page.analysis_name.SetValue(str_to_gui("Model-free test")) 
 54          self.app.gui.analysis.new_wizard.wizard._go_next(None) 
 55          page = self.app.gui.analysis.new_wizard.wizard.get_page(1) 
 56          self.app.gui.analysis.new_wizard.wizard._go_next(None) 
 57   
 58          # Get the data. 
 59          analysis_type, analysis_name, pipe_name, pipe_bundle = self.app.gui.analysis.new_wizard.get_data() 
 60   
 61          # Set up the analysis. 
 62          self.app.gui.analysis.new_analysis(analysis_type=analysis_type, analysis_name=analysis_name, pipe_name=pipe_name, pipe_bundle=pipe_bundle) 
 63   
 64          # Alias the analysis. 
 65          analysis = self.app.gui.analysis.get_page_from_name("Model-free test") 
 66   
 67          # Change the results directory. 
 68          analysis.field_results_dir.SetValue(str_to_gui(ds.tmpdir)) 
 69   
 70          # The data path. 
 71          data_path = status.install_path + sep + 'test_suite' + sep + 'shared_data' + sep + 'model_free' + sep + 'sphere' + sep 
 72   
 73          # Open and close the about window (mimicking user behaviour). 
 74          analysis._about() 
 75          analysis.about_dialog.Close() 
 76   
 77          # Launch the spin viewer window. 
 78          self.app.gui.show_tree() 
 79   
 80          # Spin loading wizard:  Initialisation. 
 81          self.app.gui.spin_viewer.load_spins_wizard() 
 82   
 83          # Spin loading wizard:  The PDB file. 
 84          page = self.app.gui.spin_viewer.wizard.get_page(0) 
 85          page.selection = 'new pdb' 
 86          self.app.gui.spin_viewer.wizard._go_next() 
 87          page = self.app.gui.spin_viewer.wizard.get_page(self.app.gui.spin_viewer.wizard._current_page) 
 88          page.uf_args['file'].SetValue(str_to_gui(status.install_path + sep + 'test_suite' + sep + 'shared_data' + sep + 'model_free' + sep + 'sphere' + sep + 'sphere.pdb')) 
 89          self.app.gui.spin_viewer.wizard._go_next() 
 90          interpreter.flush()    # Required because of the asynchronous uf call. 
 91   
 92          # Spin loading wizard:  The spin loading. 
 93          self.app.gui.spin_viewer.wizard._go_next() 
 94          interpreter.flush()    # Required because of the asynchronous uf call. 
 95   
 96          # Close the spin viewer window. 
 97          self.app.gui.spin_viewer.handler_close() 
 98   
 99          # Flush the interpreter in preparation for the synchronous user functions of the peak list wizard. 
100          interpreter.flush() 
101   
102          # Load the relaxation data. 
103          data = [ 
104              ['noe.500.out', 'noe_500', 'NOE', 500e6], 
105              ['r1.500.out',  'r1_500',  'R1',  500e6], 
106              ['r2.500.out',  'r2_500',  'R2',  500e6], 
107              ['noe.900.out', 'noe_900', 'NOE', 900e6], 
108              ['r1.900.out',  'r1_900',  'R1',  900e6], 
109              ['r2.900.out',  'r2_900',  'R2',  900e6] 
110          ] 
111          for i in range(len(data)): 
112              self._execute_uf(uf_name='relax_data.read', file=data_path+data[i][0], ri_id=data[i][1], ri_type=data[i][2], frq=data[i][3], mol_name_col=1, res_num_col=2, res_name_col=3, spin_num_col=4, spin_name_col=5, data_col=6, error_col=7) 
113   
114          # Dipole-dipole interaction wizard:  Initialisation. 
115          analysis.setup_dipole_pair() 
116   
117          # Dipole-dipole interaction wizard:  The dipole_pair.define, dipole_pair.set_dist, and dipole_pair.unit_vectors user functions. 
118          analysis.dipole_wizard._apply() 
119          interpreter.flush()    # Required because of the asynchronous uf call. 
120          page = analysis.dipole_wizard.get_page(0) 
121          page.uf_args['spin_id1'].SetValue(str_to_gui("@NE1")) 
122          page.uf_args['spin_id2'].SetValue(str_to_gui("@HE1")) 
123          analysis.dipole_wizard._go_next() 
124          interpreter.flush()    # Required because of the asynchronous uf call. 
125          analysis.dipole_wizard._go_next() 
126          interpreter.flush()    # Required because of the asynchronous uf call. 
127          analysis.dipole_wizard._go_next() 
128          interpreter.flush()    # Required because of the asynchronous uf call. 
129   
130          # Set up the CSA interaction. 
131          analysis.value_set_csa() 
132          uf_store['value.set'].wizard._go_next() 
133          interpreter.flush()    # Required because of the asynchronous uf call. 
134   
135          # Set up the nuclear isotopes. 
136          analysis.spin_isotope_heteronuc() 
137          uf_store['spin.isotope'].wizard._go_next() 
138          interpreter.flush()    # Required because of the asynchronous uf call. 
139          analysis.spin_isotope_proton() 
140          uf_store['spin.isotope'].wizard._go_next() 
141          interpreter.flush()    # Required because of the asynchronous uf call. 
142   
143          # Select only the tm0 and tm1 local tm models. 
144          analysis.local_tm_model_field.select = [True, True, False, False, False, False, False, False, False, False] 
145          analysis.local_tm_model_field.modify() 
146   
147          # Select only the m1 and m2 model-free models. 
148          analysis.mf_model_field.select = [False, True, True, False, False, False, False, False, False, False] 
149          analysis.mf_model_field.modify() 
150   
151          # Change the grid increments. 
152          analysis.grid_inc.SetValue(3) 
153          analysis.data.diff_tensor_grid_inc = {'sphere': 5, 'prolate': 5, 'oblate': 5, 'ellipsoid': 3} 
154   
155          # Set the number of Monte Carlo simulations. 
156          analysis.mc_sim_num.SetValue(2) 
157   
158          # Set the maximum number of iterations (changing the allowed values). 
159          analysis.max_iter.control.SetRange(0, 100) 
160          analysis.max_iter.SetValue(1) 
161   
162          # Set the protocol mode to automatic. 
163          analysis.mode_win.select_full_analysis() 
164          analysis.mode_dialog() 
165   
166          # Check that the data has been correctly updated prior to execution. 
167          analysis.sync_ds(upload=True) 
168          self.assertEqual(analysis.data.save_dir, ds.tmpdir) 
169          self.assertEqual(analysis.data.local_tm_models, ['tm0', 'tm1']) 
170          self.assertEqual(analysis.data.mf_models, ['m1', 'm2']) 
171          self.assertEqual(analysis.data.grid_inc, 3) 
172          self.assertEqual(analysis.data.mc_sim_num, 2) 
173          self.assertEqual(analysis.data.max_iter, 1) 
174          self.assertEqual(analysis.data.diff_tensor_grid_inc['sphere'], 5) 
175          self.assertEqual(analysis.data.diff_tensor_grid_inc['prolate'], 5) 
176          self.assertEqual(analysis.data.diff_tensor_grid_inc['oblate'], 5) 
177          self.assertEqual(analysis.data.diff_tensor_grid_inc['ellipsoid'], 3) 
178   
179          # Modify some of the class variables to speed up optimisation. 
180          auto_model_free.dauvergne_protocol.dAuvergne_protocol.opt_func_tol = 1e-5 
181          auto_model_free.dauvergne_protocol.dAuvergne_protocol.opt_max_iterations = 1000 
182   
183          # Execute relax. 
184          state = analysis.execute(wx.CommandEvent(wx.wxEVT_COMMAND_BUTTON_CLICKED, analysis.button_exec_relax.GetId())) 
185   
186          # Wait for execution to complete. 
187          if hasattr(analysis, 'thread'): 
188              analysis.thread.join() 
189   
190          # Flush all wx events. 
191          wx.Yield() 
192   
193          # Exceptions in the thread. 
194          self.check_exceptions() 
195   
196          # Check the relax controller. 
197          if status.relax_mode != 'gui': 
198              self.assertEqual(self.app.gui.controller.mc_gauge_mf.GetValue(), 100) 
199              self.assertEqual(self.app.gui.controller.progress_gauge_mf.GetValue(), 100) 
200              self.assertEqual(self.app.gui.controller.main_gauge.GetValue(), 100) 
201   
202          # Check the diffusion tensor. 
203          self.assertEqual(cdp.diff_tensor.type, 'sphere') 
204          self.assertAlmostEqual(cdp.diff_tensor.tm, 1e-8) 
205          self.assertEqual(cdp.diff_tensor.fixed, True) 
206   
207          # The global minimisation info. 
208          self.assertAlmostEqual(cdp.chi2, 4e-19) 
209   
210          # The spin ID info. 
211          mol_names = ["sphere_mol1"] * 20 
212          res_names = ["GLY"] * 20 
213          res_nums = [] 
214          for i in range(1, 10): 
215              res_nums.append(i) 
216              res_nums.append(i) 
217          res_nums.append(i) 
218          res_nums.append(i) 
219          spin_names = ["N", "H"] * 9 + ["NE1", "HE1"] 
220          spin_nums = list(range(1, 21)) 
221          isotopes = ["15N", "1H"] * 10 
222          csa = [-172e-6, None] * 10 
223          select = [True, False] * 10 
224          fixed = [False, False] * 10 
225          s2 = [0.8, None] * 10 
226          te = [20e-12, None] * 10 
227   
228          # Check the spin data. 
229          i = 0 
230          for spin, mol_name, res_num, res_name in spin_loop(full_info=True): 
231              # The ID info. 
232              self.assertEqual(mol_name, mol_names[i]) 
233              self.assertEqual(res_name, res_names[i]) 
234              self.assertEqual(res_num,  res_nums[i]) 
235              self.assertEqual(spin.name, spin_names[i]) 
236              self.assertEqual(spin.num,  spin_nums[i]) 
237   
238              # The data. 
239              self.assertEqual(spin.select, select[i]) 
240              self.assertEqual(spin.fixed, fixed[i]) 
241              self.assertEqual(spin.isotope, isotopes[i]) 
242              if csa[i] == None: 
243                  self.assertEqual(spin.csa, None) 
244              else: 
245                  self.assertAlmostEqual(spin.csa, csa[i]) 
246   
247              # The model-free data. 
248              self.assertEqual(spin.model, 'm2') 
249              self.assertEqual(spin.equation, 'mf_orig') 
250              self.assertEqual(len(spin.params), 2) 
251              self.assertEqual(spin.params[0], 's2') 
252              self.assertEqual(spin.params[1], 'te') 
253              if s2[i] == None: 
254                  self.assertEqual(spin.s2, None) 
255              else: 
256                  self.assertAlmostEqual(spin.s2, 0.8) 
257              self.assertEqual(spin.s2f, None) 
258              self.assertEqual(spin.s2s, None) 
259              self.assertEqual(spin.local_tm, None) 
260              if te[i] == None: 
261                  self.assertEqual(spin.te, None) 
262              else: 
263                  self.assertAlmostEqual(spin.te, 20e-12) 
264              self.assertEqual(spin.tf, None) 
265              self.assertEqual(spin.ts, None) 
266              self.assertEqual(spin.rex, None) 
267   
268              # The spin minimisation info. 
269              self.assertEqual(spin.chi2, None) 
270              self.assertEqual(spin.iter, None) 
271              self.assertEqual(spin.f_count, None) 
272              self.assertEqual(spin.g_count, None) 
273              self.assertEqual(spin.h_count, None) 
274              self.assertEqual(spin.warning, None) 
275   
276              # Increment the index. 
277              i += 1 
278   
279          # Check the interatomic data. 
280          i = 0 
281          for interatom in interatomic_loop(): 
282              self.assertAlmostEqual(interatom.r, 1.02 * 1e-10) 
283