Source Code for Module test_suite.system_tests.spectrum

  1  ############################################################################### 
  2  #                                                                             # 
  3  # Copyright (C) 2008-2014 Edward d'Auvergne                                   # 
  4  # Copyright (C) 2008 Sebastien Morin                                          # 
  5  # Copyright (C) 2013-2014 Troels E. Linnet                                    # 
  6  #                                                                             # 
  7  # This file is part of the program relax (http://www.nmr-relax.com).          # 
  8  #                                                                             # 
  9  # This program is free software: you can redistribute it and/or modify        # 
 10  # it under the terms of the GNU General Public License as published by        # 
 11  # the Free Software Foundation, either version 3 of the License, or           # 
 12  # (at your option) any later version.                                         # 
 13  #                                                                             # 
 14  # This program is distributed in the hope that it will be useful,             # 
 15  # but WITHOUT ANY WARRANTY; without even the implied warranty of              # 
 16  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               # 
 17  # GNU General Public License for more details.                                # 
 18  #                                                                             # 
 19  # You should have received a copy of the GNU General Public License           # 
 20  # along with this program.  If not, see <http://www.gnu.org/licenses/>.       # 
 21  #                                                                             # 
 22  ############################################################################### 
 23   
 24  # Python module imports. 
 25  from os import sep 
 26  from os.path import basename, dirname 
 27  from tempfile import mkdtemp, NamedTemporaryFile 
 28   
 29  # relax module imports. 
 30  from data_store import Relax_data_store; ds = Relax_data_store() 
 31  import dep_check 
 32  from pipe_control.mol_res_spin import spin_loop 
 33  from status import Status; status = Status() 
 34  from test_suite.system_tests.base_classes import SystemTestCase 
 35   
 36   
 37 -class Spectrum(SystemTestCase): 
 38      """TestCase class for the functional tests for the support of different spectrum intensity calculation or errors, signal to noise and plotting.""" 
 39   
 40   
 41 -    def setUp(self): 
 42          """Set up for all the functional tests.""" 
 43   
 44          # Create a temporary directory for dumping files. 
 45          ds.tmpdir = mkdtemp() 
 46          self.tmpdir = ds.tmpdir 
 47   
 48 -    def setup_signal_noise_ratio(self): 
 49          """Setup intensity data. 
 50   
 51          This uses the data from paper at U{http://dx.doi.org/10.1073/pnas.0509100103}.  This is CPMG data with a fixed relaxation time period.  Experiment in 0.48 M GuHCl (guanidine hydrochloride). 
 52          """ 
 53   
 54          # Set pipe name, bundle and type. 
 55          pipe_name = 'base pipe' 
 56          pipe_bundle = 'relax_disp' 
 57          pipe_type = 'relax_disp' 
 58   
 59          # Create the data pipe. 
 60          self.interpreter.pipe.create(pipe_name=pipe_name, bundle=pipe_bundle, pipe_type=pipe_type) 
 61   
 62          data_path = status.install_path + sep+'test_suite'+sep+'shared_data'+sep+'dispersion'+sep+'KTeilum_FMPoulsen_MAkke_2006'+sep+'bug_neg_int_acbp_cpmg_disp_048MGuHCl_40C_041223' 
 63   
 64          # Create the spins 
 65          self.interpreter.spectrum.read_spins(file="peaks_list_max_standard.ser", dir=data_path) 
 66   
 67          # Name the isotope for field strength scaling. 
 68          self.interpreter.spin.isotope(isotope='15N') 
 69   
 70          # Read the spectrum from NMRSeriesTab file. The "auto" will generate spectrum name of form: Z_A{i} 
 71          self.interpreter.spectrum.read_intensities(file="peaks_list_max_standard.ser", dir=data_path, spectrum_id='auto', int_method='height') 
 72   
 73          # Loop over the spectra settings. 
 74          ncycfile=open(data_path + sep + 'ncyc.txt', 'r') 
 75   
 76          # Make empty ncyclist 
 77          ncyclist = [] 
 78   
 79          i = 0 
 80          for line in ncycfile: 
 81              ncyc = line.split()[0] 
 82              time_T2 = float(line.split()[1]) 
 83              vcpmg = line.split()[2] 
 84              set_sfrq = float(line.split()[3]) 
 85              rmsd_err = float(line.split()[4]) 
 86   
 87              # Test if spectrum is a reference 
 88              if float(vcpmg) == 0.0: 
 89                  vcpmg = None 
 90              else: 
 91                  vcpmg = round(float(vcpmg), 3) 
 92   
 93              # Add ncyc to list 
 94              ncyclist.append(int(ncyc)) 
 95   
 96              # Set the current spectrum id 
 97              current_id = "Z_A%s"%(i) 
 98   
 99              # Set the current experiment type. 
100              self.interpreter.relax_disp.exp_type(spectrum_id=current_id, exp_type='SQ CPMG') 
101   
102              # Set the peak intensity errors, as defined as the baseplane RMSD. 
103              self.interpreter.spectrum.baseplane_rmsd(error=rmsd_err, spectrum_id=current_id) 
104   
105              # Set the NMR field strength of the spectrum. 
106              self.interpreter.spectrometer.frequency(id=current_id, frq=set_sfrq, units='MHz') 
107   
108              # Relaxation dispersion CPMG constant time delay T (in s). 
109              self.interpreter.relax_disp.relax_time(spectrum_id=current_id, time=time_T2) 
110   
111              # Set the relaxation dispersion CPMG frequencies. 
112              self.interpreter.relax_disp.cpmg_setup(spectrum_id=current_id, cpmg_frq=vcpmg) 
113   
114              i += 1 
115   
116          # Perform the error analysis. 
117          self.interpreter.spectrum.error_analysis_per_field() 
118   
119          # Store the reference intensities and RMSD. 
120          ds.data = [ 
121          [1, 1711.104, 3040.110, 8.514, 121.681, +5.586445e+05, 'A3N-HN', 1.0000, 1.7492, 0.9997, 1.0075, 1.0081, 0.8991, 1.0205, 0.9893, 1.0145, 1.0078, 1.0133, 1.0020, 0.9995, 1.0020, 1.0249, 1.7571, 1.0016], 
122          [2, 2011.491, 4112.494, 8.025, 117.805, +6.213668e+05, 'E4N-HN', 1.0000, 1.6032, -0.8322, 0.9920, 0.9951, 0.8300, 0.9458, 0.9689, 0.9246, 0.9936, 0.9914, 0.9842, 1.0011, 0.8529, 0.9727, 1.5845, 0.9822], 
123          [3, 1974.019, 2629.250, 8.086, 123.166, +4.592940e+05, 'F5N-HN', 1.0000, 1.8235, 0.8614, 1.0135, 1.0134, 0.8825, 0.9332, 0.9772, 0.9273, 0.9803, 0.9986, 1.0000, 1.0012, 0.8923, 0.9421, 1.8102, 1.0062], 
124          [4, 1608.518, 3683.374, 8.681, 119.356, +5.293190e+05, 'D6N-HN', 1.0000, 1.6865, 0.8531, 1.0052, 1.0065, 0.8530, 0.9280, 0.9594, 0.8989, 0.9914, 1.0115, 0.9743, 1.0063, 0.8177, 0.9264, 1.6855, 0.9981], 
125          ] 
126   
127          ds.rmsd = [2.47e+03, 2.34e+03, 2.41e+03, 2.42e+03, 2.45e+03, 2.42e+03, 2.42e+03, 2.44e+03, 2.39e+03, 2.4e+03, 2.42e+03, 2.46e+03, 2.41e+03, 2.45e+03, 2.45e+03, 2.39e+03, 2.45e+03] 
128   
129   
130 -    def test_signal_noise_ratio(self): 
131          """Test calculation of signal to noise ratio. 
132          """ 
133   
134   
135          # Setup data. 
136          self.setup_signal_noise_ratio() 
137   
138          # Test the signal to noise ratio calculation. 
139          self.interpreter.spectrum.sn_ratio() 
140   
141          # Assign counter 
142          i = 0 
143          for cur_spin, cur_spin_id in spin_loop(return_id=True, skip_desel=True): 
144              # Test assignment. 
145              self.assertEqual(cur_spin_id, ":%s@N"%ds.data[i][6][1]) 
146   
147              # Loop over intensity columns. 
148              for j in range(17): 
149                  # Test intensity. 
150                  data_int = ds.data[i][j+7] * ds.data[i][5] 
151                  pint = cur_spin.peak_intensity['Z_A%i'%j] 
152                  self.assertEqual(pint, data_int) 
153   
154                  # Test baseplane_rmsd. 
155                  data_rmsd = ds.rmsd[j] 
156                  self.assertEqual(cur_spin.baseplane_rmsd['Z_A%i'%j], data_rmsd) 
157   
158                  # Test the calculated peak_intensity_err. 
159                  # Since we have measured intensity height, and have not specified replications, this is the same as rmsd. 
160                  pint_err = cur_spin.peak_intensity_err['Z_A%i'%j] 
161                  self.assertEqual(pint_err, ds.rmsd[j]) 
162   
163                  # Test the signal to noise ratio. 
164                  sn_ratio = data_int / data_rmsd 
165                  self.assertEqual(cur_spin.sn_ratio['Z_A%i'%j], sn_ratio) 
166                  self.assertEqual(cur_spin.sn_ratio['Z_A%i'%j], pint/pint_err) 
167   
168              # Add to counter 
169              i += 1 
170   
171   
172 -    def test_grace_int(self): 
173          """Test grace plotting function for plotting the intensities per residue. 
174          """ 
175   
176   
177          # Setup data. 
178          self.setup_signal_noise_ratio() 
179   
180          # Deselect spin with negative intensity. 
181          self.interpreter.deselect.spin(spin_id=':4@N', boolean='AND', change_all=False) 
182   
183          # Test show grace. If showing, the temporary directory created, should not be deleted. 
184          show_grace = False 
185          if show_grace: 
186              outfile= NamedTemporaryFile(delete=False).name 
187              filedir = dirname(outfile) 
188          else: 
189              filedir = self.tmpdir 
190          outfile = 'int.agr' 
191   
192          self.interpreter.grace.write(x_data_type='res_num', y_data_type='peak_intensity', file=outfile, dir=filedir, force=True) 
193   
194          # View the plotting. 
195          if show_grace: 
196              self.interpreter.grace.view(file=outfile, dir=filedir, grace_exe='xmgrace') 
197   
198   
199 -    def test_grace_sn_ratio(self): 
200          """Test grace plotting function for plotting the signal to noise ratio per residue. 
201          """ 
202   
203          # Setup data. 
204          self.setup_signal_noise_ratio() 
205   
206          # Calculate the signal to noise ratio calculation. 
207          self.interpreter.spectrum.sn_ratio() 
208   
209          # Deselect spin with negative intensity. 
210          self.interpreter.deselect.spin(spin_id=':4@N', boolean='AND', change_all=False) 
211   
212          # Test show grace. If showing, the temporary directory created, should not be deleted. 
213          show_grace = False 
214          if show_grace: 
215              outfile= NamedTemporaryFile(delete=False).name 
216              filedir = dirname(outfile) 
217          else: 
218              filedir = self.tmpdir 
219          outfile = 'int_sn.agr' 
220   
221          self.interpreter.grace.write(x_data_type='res_num', y_data_type='sn_ratio', file=outfile, dir=filedir, force=True) 
222   
223          # View the plotting. 
224          if show_grace: 
225              self.interpreter.grace.view(file=outfile, dir=filedir, grace_exe='xmgrace') 
226   
227   
228 -    def test_deselect_sn_ratio_all(self): 
229          """Test the deselect.sn_ratio for signal to noise ratios, where all ID should evaluate to True. 
230          """ 
231   
232          # Setup data. 
233          self.setup_signal_noise_ratio() 
234   
235          # Calculate the signal to noise ratio calculation. 
236          self.interpreter.spectrum.sn_ratio() 
237   
238          # deselect spins. 
239          self.interpreter.deselect.sn_ratio(ratio=400.0, operation='<', all_sn=True) 
240   
241          # Test 
242          spin_ids_sel = [] 
243          spin_ids_desel = [] 
244   
245          # Collect spin ids which are selected. 
246          for cur_spin, cur_spin_id in spin_loop(return_id=True, skip_desel=False): 
247              if cur_spin.select: 
248                  spin_ids_sel.append(cur_spin_id) 
249              else: 
250                  spin_ids_desel.append(cur_spin_id) 
251   
252          # Make the test: 
253          self.assertEqual(spin_ids_sel, [':3@N', ':4@N']) 
254          self.assertEqual(spin_ids_desel, [':5@N', ':6@N']) 
255   
256   
257 -    def test_deselect_sn_ratio_any(self): 
258          """Test the deselect.sn_ratio for signal to noise ratios, where any ID should evaluate to True. 
259          """ 
260   
261          # Setup data. 
262          self.setup_signal_noise_ratio() 
263   
264          # Calculate the signal to noise ratio calculation. 
265          self.interpreter.spectrum.sn_ratio() 
266   
267          # Deselect spins. 
268          self.interpreter.deselect.sn_ratio(ratio=200.0, operation='<', all_sn=False) 
269   
270          # Test 
271          spin_ids_sel = [] 
272          spin_ids_desel = [] 
273   
274          # Collect spin ids which are selected. 
275          for cur_spin, cur_spin_id in spin_loop(return_id=True, skip_desel=False): 
276              if cur_spin.select: 
277                  spin_ids_sel.append(cur_spin_id) 
278              else: 
279                  spin_ids_desel.append(cur_spin_id) 
280   
281          # Make the test: 
282          self.assertEqual(spin_ids_sel, [':3@N']) 
283          self.assertEqual(spin_ids_desel, [':4@N', ':5@N', ':6@N']) 
284   
285   
286 -    def test_select_sn_ratio_all(self): 
287          """Test the select.sn_ratio for signal to noise ratios, where all ID should evaluate to True. 
288          """ 
289   
290          # Setup data. 
291          self.setup_signal_noise_ratio() 
292   
293          # Calculate the signal to noise ratio calculation. 
294          self.interpreter.spectrum.sn_ratio() 
295   
296          # First deselect all spins. 
297          self.interpreter.deselect.all() 
298   
299          # Select spins. 
300          self.interpreter.select.sn_ratio(ratio=400.0, operation='<', all_sn=True) 
301   
302          # Test 
303          spin_ids_sel = [] 
304          spin_ids_desel = [] 
305   
306          # Collect spin ids which are selected. 
307          for cur_spin, cur_spin_id in spin_loop(return_id=True, skip_desel=False): 
308              if cur_spin.select: 
309                  spin_ids_sel.append(cur_spin_id) 
310              else: 
311                  spin_ids_desel.append(cur_spin_id) 
312   
313          # Make the test: 
314          self.assertEqual(spin_ids_sel, [':5@N', ':6@N']) 
315          self.assertEqual(spin_ids_desel, [':3@N', ':4@N']) 
316   
317   
318 -    def test_select_sn_ratio_any(self): 
319          """Test the select.sn_ratio for signal to noise ratios, where any ID should evaluate to True. 
320          """ 
321   
322          # Setup data. 
323          self.setup_signal_noise_ratio() 
324   
325          # Calculate the signal to noise ratio calculation. 
326          self.interpreter.spectrum.sn_ratio() 
327   
328          # First deselect all spins. 
329          self.interpreter.deselect.all() 
330   
331          # Select spins. 
332          self.interpreter.select.sn_ratio(ratio=200.0, operation='<', all_sn=False) 
333   
334          # Test 
335          spin_ids_sel = [] 
336          spin_ids_desel = [] 
337   
338          # Collect spin ids which are selected. 
339          for cur_spin, cur_spin_id in spin_loop(return_id=True, skip_desel=False): 
340              if cur_spin.select: 
341                  spin_ids_sel.append(cur_spin_id) 
342              else: 
343                  spin_ids_desel.append(cur_spin_id) 
344   
345          # Make the test: 
346          self.assertEqual(spin_ids_sel, [':4@N', ':5@N', ':6@N']) 
347          self.assertEqual(spin_ids_desel, [':3@N']) 
348