1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 from copy import deepcopy
24 from LinearAlgebra import inverse
25 from math import pi
26 from Numeric import Float64, array, identity, matrixmultiply, ones, transpose, zeros
27 from re import match, search
28 from string import replace, split
29 import sys
30
31 from base_class import Common_functions
32 from maths_fns.mf import Mf
33 from minimise.generic import generic_minimise
34 from float import isNaN,isInf
35
36
39 """Class containing functions specific to model-free analysis."""
40
41 self.relax = relax
42
43
44 self.molmol = Molmol(self.relax)
45
46
48 """Function for testing if the model-free parameter values are set."""
49
50
51 data = self.relax.data.res[self.run][index]
52
53
54 if data.select == 0:
55 return
56
57
58 for j in xrange(len(data.params)):
59
60 if data.params[j] == 'local_tm' and data.local_tm == None:
61 return data.params[j]
62
63
64 elif data.params[j] == 'S2' and data.s2 == None:
65 return data.params[j]
66
67
68 elif data.params[j] == 'S2f' and data.s2f == None:
69 return data.params[j]
70
71
72 elif data.params[j] == 'S2s' and data.s2s == None:
73 return data.params[j]
74
75
76 elif data.params[j] == 'te' and data.te == None:
77 return data.params[j]
78
79
80 elif data.params[j] == 'tf' and data.tf == None:
81 return data.params[j]
82
83
84 elif data.params[j] == 'ts' and data.ts == None:
85 return data.params[j]
86
87
88 elif data.params[j] == 'Rex' and data.rex == None:
89 return data.params[j]
90
91
92 elif data.params[j] == 'r' and data.r == None:
93 return data.params[j]
94
95
96 elif data.params[j] == 'CSA' and data.csa == None:
97 return data.params[j]
98
99
101 """Function for assembling various pieces of data into a Numeric parameter array."""
102
103
104 self.param_names = []
105
106
107 if self.param_set == 'diff' or self.param_set == 'all':
108
109 if self.relax.data.diff[self.run].type == 'sphere':
110 self.param_names.append('tm')
111
112
113 elif self.relax.data.diff[self.run].type == 'spheroid':
114 self.param_names.append('tm')
115 self.param_names.append('Da')
116 self.param_names.append('theta')
117 self.param_names.append('phi')
118
119
120 elif self.relax.data.diff[self.run].type == 'ellipsoid':
121 self.param_names.append('tm')
122 self.param_names.append('Da')
123 self.param_names.append('Dr')
124 self.param_names.append('alpha')
125 self.param_names.append('beta')
126 self.param_names.append('gamma')
127
128
129 if self.param_set != 'diff':
130 for i in xrange(len(self.relax.data.res[self.run])):
131
132 if index != None and i != index:
133 continue
134
135
136 if not self.relax.data.res[self.run][i].select:
137 continue
138
139
140 for j in xrange(len(self.relax.data.res[self.run][i].params)):
141 self.param_names.append(self.relax.data.res[self.run][i].params[j])
142
143
145 """Function for assembling various pieces of data into a Numeric parameter array."""
146
147
148 param_vector = []
149 if param_set == None:
150 param_set = self.param_set
151
152
153 if sim_index != None and (param_set == 'diff' or param_set == 'all'):
154
155 if self.relax.data.diff[self.run].type == 'sphere':
156 param_vector.append(self.relax.data.diff[self.run].tm_sim[sim_index])
157
158
159 elif self.relax.data.diff[self.run].type == 'spheroid':
160 param_vector.append(self.relax.data.diff[self.run].tm_sim[sim_index])
161 param_vector.append(self.relax.data.diff[self.run].Da_sim[sim_index])
162 param_vector.append(self.relax.data.diff[self.run].theta_sim[sim_index])
163 param_vector.append(self.relax.data.diff[self.run].phi_sim[sim_index])
164
165
166 elif self.relax.data.diff[self.run].type == 'ellipsoid':
167 param_vector.append(self.relax.data.diff[self.run].tm_sim[sim_index])
168 param_vector.append(self.relax.data.diff[self.run].Da_sim[sim_index])
169 param_vector.append(self.relax.data.diff[self.run].Dr_sim[sim_index])
170 param_vector.append(self.relax.data.diff[self.run].alpha_sim[sim_index])
171 param_vector.append(self.relax.data.diff[self.run].beta_sim[sim_index])
172 param_vector.append(self.relax.data.diff[self.run].gamma_sim[sim_index])
173
174
175 elif param_set == 'diff' or param_set == 'all':
176
177 if self.relax.data.diff[self.run].type == 'sphere':
178 param_vector.append(self.relax.data.diff[self.run].tm)
179
180
181 elif self.relax.data.diff[self.run].type == 'spheroid':
182 param_vector.append(self.relax.data.diff[self.run].tm)
183 param_vector.append(self.relax.data.diff[self.run].Da)
184 param_vector.append(self.relax.data.diff[self.run].theta)
185 param_vector.append(self.relax.data.diff[self.run].phi)
186
187
188 elif self.relax.data.diff[self.run].type == 'ellipsoid':
189 param_vector.append(self.relax.data.diff[self.run].tm)
190 param_vector.append(self.relax.data.diff[self.run].Da)
191 param_vector.append(self.relax.data.diff[self.run].Dr)
192 param_vector.append(self.relax.data.diff[self.run].alpha)
193 param_vector.append(self.relax.data.diff[self.run].beta)
194 param_vector.append(self.relax.data.diff[self.run].gamma)
195
196
197 if param_set != 'diff':
198 for i in xrange(len(self.relax.data.res[self.run])):
199
200 if not self.relax.data.res[self.run][i].select:
201 continue
202
203
204 if (param_set == 'mf' or param_set == 'local_tm') and index != None and i != index:
205 continue
206
207
208 for j in xrange(len(self.relax.data.res[self.run][i].params)):
209
210 if self.relax.data.res[self.run][i].params[j] == 'local_tm':
211 if self.relax.data.res[self.run][i].local_tm == None:
212 param_vector.append(0.0)
213 elif sim_index != None:
214 param_vector.append(self.relax.data.res[self.run][i].local_tm_sim[sim_index])
215 else:
216 param_vector.append(self.relax.data.res[self.run][i].local_tm)
217
218
219 elif self.relax.data.res[self.run][i].params[j] == 'S2':
220 if self.relax.data.res[self.run][i].s2 == None:
221 param_vector.append(0.0)
222 elif sim_index != None:
223 param_vector.append(self.relax.data.res[self.run][i].s2_sim[sim_index])
224 else:
225 param_vector.append(self.relax.data.res[self.run][i].s2)
226
227
228 elif self.relax.data.res[self.run][i].params[j] == 'S2f':
229 if self.relax.data.res[self.run][i].s2f == None:
230 param_vector.append(0.0)
231 elif sim_index != None:
232 param_vector.append(self.relax.data.res[self.run][i].s2f_sim[sim_index])
233 else:
234 param_vector.append(self.relax.data.res[self.run][i].s2f)
235
236
237 elif self.relax.data.res[self.run][i].params[j] == 'S2s':
238 if self.relax.data.res[self.run][i].s2s == None:
239 param_vector.append(0.0)
240 elif sim_index != None:
241 param_vector.append(self.relax.data.res[self.run][i].s2s_sim[sim_index])
242 else:
243 param_vector.append(self.relax.data.res[self.run][i].s2s)
244
245
246 elif self.relax.data.res[self.run][i].params[j] == 'te':
247 if self.relax.data.res[self.run][i].te == None:
248 param_vector.append(0.0)
249 elif sim_index != None:
250 param_vector.append(self.relax.data.res[self.run][i].te_sim[sim_index])
251 else:
252 param_vector.append(self.relax.data.res[self.run][i].te)
253
254
255 elif self.relax.data.res[self.run][i].params[j] == 'tf':
256 if self.relax.data.res[self.run][i].tf == None:
257 param_vector.append(0.0)
258 elif sim_index != None:
259 param_vector.append(self.relax.data.res[self.run][i].tf_sim[sim_index])
260 else:
261 param_vector.append(self.relax.data.res[self.run][i].tf)
262
263
264 elif self.relax.data.res[self.run][i].params[j] == 'ts':
265 if self.relax.data.res[self.run][i].ts == None:
266 param_vector.append(0.0)
267 elif sim_index != None:
268 param_vector.append(self.relax.data.res[self.run][i].ts_sim[sim_index])
269 else:
270 param_vector.append(self.relax.data.res[self.run][i].ts)
271
272
273 elif self.relax.data.res[self.run][i].params[j] == 'Rex':
274 if self.relax.data.res[self.run][i].rex == None:
275 param_vector.append(0.0)
276 elif sim_index != None:
277 param_vector.append(self.relax.data.res[self.run][i].rex_sim[sim_index])
278 else:
279 param_vector.append(self.relax.data.res[self.run][i].rex)
280
281
282 elif self.relax.data.res[self.run][i].params[j] == 'r':
283 if self.relax.data.res[self.run][i].r == None:
284 param_vector.append(0.0)
285 elif sim_index != None:
286 param_vector.append(self.relax.data.res[self.run][i].r_sim[sim_index])
287 else:
288 param_vector.append(self.relax.data.res[self.run][i].r)
289
290
291 elif self.relax.data.res[self.run][i].params[j] == 'CSA':
292 if self.relax.data.res[self.run][i].csa == None:
293 param_vector.append(0.0)
294 elif sim_index != None:
295 param_vector.append(self.relax.data.res[self.run][i].csa_sim[sim_index])
296 else:
297 param_vector.append(self.relax.data.res[self.run][i].csa)
298
299
300 else:
301 raise RelaxError, "Unknown parameter."
302
303
304 return array(param_vector, Float64)
305
306
308 """Function for creating the scaling matrix."""
309
310
311 if len(self.param_vector) == 0:
312 self.scaling_matrix = zeros((0, 0), Float64)
313 else:
314 self.scaling_matrix = identity(len(self.param_vector), Float64)
315 i = 0
316
317
318 if not scaling:
319 return
320
321
322 ti_scaling = 1e-12
323
324
325 if self.param_set == 'diff' or self.param_set == 'all':
326
327 if self.relax.data.diff[self.run].type == 'sphere':
328
329 self.scaling_matrix[i, i] = ti_scaling
330
331
332 i = i + 1
333
334
335 elif self.relax.data.diff[self.run].type == 'spheroid':
336
337 self.scaling_matrix[i, i] = ti_scaling
338 self.scaling_matrix[i+1, i+1] = 1e7
339 self.scaling_matrix[i+2, i+2] = 1.0
340 self.scaling_matrix[i+3, i+3] = 1.0
341
342
343 i = i + 4
344
345
346 elif self.relax.data.diff[self.run].type == 'ellipsoid':
347
348 self.scaling_matrix[i, i] = ti_scaling
349 self.scaling_matrix[i+1, i+1] = 1e7
350 self.scaling_matrix[i+2, i+2] = 1.0
351 self.scaling_matrix[i+3, i+3] = 1.0
352 self.scaling_matrix[i+4, i+4] = 1.0
353 self.scaling_matrix[i+5, i+5] = 1.0
354
355
356 i = i + 6
357
358
359 if self.param_set != 'diff':
360
361 for j in xrange(len(self.relax.data.res[self.run])):
362
363 if not self.relax.data.res[self.run][j].select:
364 continue
365
366
367 if index != None and j != index:
368 continue
369
370
371 for k in xrange(len(self.relax.data.res[self.run][j].params)):
372
373 if self.relax.data.res[self.run][j].params[k] == 'local_tm' or search('^t', self.relax.data.res[self.run][j].params[k]):
374 self.scaling_matrix[i, i] = ti_scaling
375
376
377 elif self.relax.data.res[self.run][j].params[k] == 'Rex':
378 self.scaling_matrix[i, i] = 1.0 / (2.0 * pi * self.relax.data.res[self.run][j].frq[0]) ** 2
379
380
381 elif self.relax.data.res[self.run][j].params[k] == 'r':
382 self.scaling_matrix[i, i] = 1e-10
383
384
385 elif self.relax.data.res[self.run][j].params[k] == 'CSA':
386 self.scaling_matrix[i, i] = 1e-4
387
388
389 i = i + 1
390
391
392 - def back_calc(self, run=None, index=None, ri_label=None, frq_label=None, frq=None):
393 """Back-calculation of relaxation data from the model-free parameter values."""
394
395
396 self.run = run
397
398
399 value = self.minimise(run=self.run, min_algor='back_calc', min_options=(index, ri_label, frq_label, frq))
400
401
402 return value
403
404
405 - def calculate(self, run=None, res_num=None, print_flag=1, sim_index=None):
406 """Calculation of the model-free chi-squared value."""
407
408
409 self.run = run
410 self.print_flag = print_flag
411
412
413 if not self.relax.data.res.has_key(self.run):
414 raise RelaxNoSequenceError, self.run
415
416
417 index = None
418 if res_num != None:
419
420 for i in xrange(len(self.relax.data.res[self.run])):
421
422 if self.relax.data.res[self.run][i].num == res_num:
423 index = i
424 break
425
426
427 if index == None:
428 raise RelaxNoResError, res_num
429
430
431 self.param_set = self.determine_param_set_type()
432
433
434 if self.param_set != 'local_tm' and not self.relax.data.diff.has_key(self.run):
435 raise RelaxNoTensorError, self.run
436
437
438 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'sphere' and not self.relax.data.pdb.has_key(self.run):
439 raise RelaxNoPdbError, self.run
440
441
442 if not hasattr(self.relax.data, 'gx'):
443 raise RelaxNucleusError
444
445
446 for i in xrange(len(self.relax.data.res[self.run])):
447
448 data = self.relax.data.res[self.run][i]
449
450
451 if not data.select:
452 continue
453
454
455 if index != None and index != i:
456 continue
457
458
459 if not data.model:
460 raise RelaxNoModelError, self.run
461
462
463 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'sphere' and not hasattr(data, 'xh_vect'):
464 raise RelaxNoVectorsError, self.run
465
466
467 unset_param = self.are_mf_params_set(i)
468 if unset_param != None:
469 raise RelaxNoValueError, unset_param
470
471
472 if not hasattr(data, 'csa') or data.csa == None:
473 raise RelaxNoValueError, "CSA"
474
475
476 if not hasattr(data, 'r') or data.r == None:
477 raise RelaxNoValueError, "bond length"
478
479
480 if not hasattr(data, 'relax_data') or not hasattr(data, 'relax_error'):
481 continue
482
483
484 for j in xrange(len(data.relax_error)):
485 if data.relax_error[j] == 0.0:
486 raise RelaxError, "Zero error for residue '" + `data.num` + " " + data.name + "', calculation not possible."
487 elif data.relax_error[j] < 0.0:
488 raise RelaxError, "Negative error for residue '" + `data.num` + " " + data.name + "', calculation not possible."
489
490
491 self.param_vector = self.assemble_param_vector(index=i, sim_index=sim_index)
492
493
494 if sim_index == None:
495 relax_data = [data.relax_data]
496 r = [data.r]
497 csa = [data.csa]
498 else:
499 relax_data = [data.relax_sim_data[sim_index]]
500 r = [data.r_sim[sim_index]]
501 csa = [data.csa_sim[sim_index]]
502
503
504 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'sphere':
505 xh_unit_vectors = [data.xh_vect]
506 else:
507 xh_unit_vectors = [None]
508
509
510 num_params = [len(data.params)]
511
512
513 param_values = [self.assemble_param_vector(param_set='mf')]
514
515
516 relax_data = [array(data.relax_data, Float64)]
517 relax_error = [array(data.relax_error, Float64)]
518
519
520 if self.param_set == 'local_tm':
521 diff_params = [self.relax.data.res[self.run][i].local_tm]
522 diff_type = 'sphere'
523 else:
524
525 diff_data = self.relax.data.diff[self.run]
526
527
528 diff_type = diff_data.type
529
530
531 if diff_type == 'sphere':
532 diff_params = [diff_data.tm]
533
534
535 elif diff_type == 'spheroid':
536 diff_params = [diff_data.tm, diff_data.Da, diff_data.theta, diff_data.phi]
537
538
539 elif diff_type == 'ellipsoid':
540 diff_params = [diff_data.tm, diff_data.Da, diff_data.Dr, diff_data.alpha, diff_data.beta, diff_data.gamma]
541
542
543 self.mf = Mf(init_params=self.param_vector, param_set='mf', diff_type=diff_type, diff_params=diff_params, num_res=1, equations=[data.equation], param_types=[data.params], param_values=param_values, relax_data=relax_data, errors=relax_error, bond_length=r, csa=csa, num_frq=[data.num_frq], frq=[data.frq], num_ri=[data.num_ri], remap_table=[data.remap_table], noe_r1_table=[data.noe_r1_table], ri_labels=[data.ri_labels], gx=self.relax.data.gx, gh=self.relax.data.gh, g_ratio=self.relax.data.g_ratio, h_bar=self.relax.data.h_bar, mu0=self.relax.data.mu0, num_params=num_params, vectors=xh_unit_vectors)
544
545
546 try:
547 chi2 = self.mf.func(self.param_vector)
548 except OverflowError:
549 chi2 = 1e200
550
551
552 if self.param_set == 'all' or self.param_set == 'diff':
553 self.relax.data.chi2[self.run] = self.relax.data.chi2[self.run] + chi2
554 else:
555 self.relax.data.res[self.run][i].chi2 = chi2
556
557
558 - def copy(self, run1=None, run2=None, sim=None):
559 """Function for copying all model-free data from run1 to run2."""
560
561
562 if not run1 in self.relax.data.run_names:
563 raise RelaxNoRunError, run1
564
565
566 if not run2 in self.relax.data.run_names:
567 raise RelaxNoRunError, run2
568
569
570 function_type = self.relax.data.run_types[self.relax.data.run_names.index(run1)]
571 if function_type != 'mf':
572 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type)
573
574
575 function_type = self.relax.data.run_types[self.relax.data.run_names.index(run2)]
576 if function_type != 'mf':
577 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type)
578
579
580 if not self.relax.data.res.has_key(run1):
581 raise RelaxNoSequenceError, run1
582
583
584 if not self.relax.data.res.has_key(run2):
585 raise RelaxNoSequenceError, run2
586
587
588 names = self.data_names()
589
590
591 for i in xrange(len(self.relax.data.res[run1])):
592
593 data1 = self.relax.data.res[run1][i]
594 data2 = self.relax.data.res[run2][i]
595
596
597 for name in names:
598
599 if not sim:
600
601 if not hasattr(data1, name):
602 continue
603
604
605 setattr(data2, name, deepcopy(getattr(data1, name)))
606
607
608 else:
609
610 name = name + '_sim'
611
612
613 if not hasattr(data1, name) or not hasattr(data2, name):
614 continue
615
616
617 object1 = getattr(data1, name)
618 object2 = getattr(data2, name)
619
620
621 object2[sim] = object1[sim]
622
623
647
648
649 - def create_model(self, run=None, model=None, equation=None, params=None, res_num=None):
650 """Function to create a model-free model."""
651
652
653 self.run = run
654
655
656 if not self.run in self.relax.data.run_names:
657 raise RelaxNoRunError, self.run
658
659
660 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)]
661 if function_type != 'mf':
662 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type)
663
664
665 if not self.relax.data.res.has_key(self.run):
666 raise RelaxNoSequenceError, self.run
667
668
669 valid_types = ['mf_orig', 'mf_ext', 'mf_ext2']
670 if not equation in valid_types:
671 raise RelaxError, "The model-free equation type argument " + `equation` + " is invalid and should be one of " + `valid_types` + "."
672
673
674 s2, te, s2f, tf, s2s, ts, rex, csa, r = 0, 0, 0, 0, 0, 0, 0, 0, 0
675 for i in xrange(len(params)):
676
677 invalid_param = 0
678
679
680 if params[i] == 'S2':
681
682 if s2:
683 invalid_param = 1
684 s2 = 1
685
686
687 s2s_flag = 0
688 for j in xrange(len(params)):
689 if params[j] == 'S2s':
690 s2s_flag = 1
691 if s2s_flag:
692 invalid_param = 1
693
694
695 elif params[i] == 'te':
696
697 if equation == 'mf_ext' or te:
698 invalid_param = 1
699 te = 1
700
701
702 s2_flag = 0
703 for j in xrange(len(params)):
704 if params[j] == 'S2':
705 s2_flag = 1
706 if not s2_flag:
707 invalid_param = 1
708
709
710 elif params[i] == 'S2f':
711
712 if equation == 'mf_orig' or s2f:
713 invalid_param = 1
714 s2f = 1
715
716
717 elif params[i] == 'S2s':
718
719 if equation == 'mf_orig' or s2s:
720 invalid_param = 1
721 s2s = 1
722
723
724 elif params[i] == 'tf':
725
726 if equation == 'mf_orig' or tf:
727 invalid_param = 1
728 tf = 1
729
730
731 s2f_flag = 0
732 for j in xrange(len(params)):
733 if params[j] == 'S2f':
734 s2f_flag = 1
735 if not s2f_flag:
736 invalid_param = 1
737
738
739 elif params[i] == 'ts':
740
741 if equation == 'mf_orig' or ts:
742 invalid_param = 1
743 ts = 1
744
745
746 flag = 0
747 for j in xrange(len(params)):
748 if params[j] == 'S2' or params[j] == 'S2f':
749 flag = 1
750 if not flag:
751 invalid_param = 1
752
753
754 elif params[i] == 'Rex':
755 if rex:
756 invalid_param = 1
757 rex = 1
758
759
760 elif params[i] == 'r':
761 if r:
762 invalid_param = 1
763 r = 1
764
765
766 elif params[i] == 'CSA':
767 if csa:
768 invalid_param = 1
769 csa = 1
770
771
772 else:
773 raise RelaxError, "The parameter " + params[i] + " is not supported."
774
775
776 if invalid_param:
777 raise RelaxError, "The parameter array " + `params` + " contains an invalid combination of parameters."
778
779
780 self.model_setup(run, model, equation, params, res_num)
781
782
784 """Function for initialising the data structures."""
785
786
787 data_names = self.data_names()
788
789
790 for name in data_names:
791
792 list_data = [ 'params' ]
793 if name in list_data:
794 init_data = []
795
796
797 none_data = [ 'equation',
798 'model',
799 's2',
800 's2f',
801 's2s',
802 'local_tm',
803 'te',
804 'tf',
805 'ts',
806 'rex',
807 'r',
808 'csa',
809 'chi2',
810 'iter',
811 'f_count',
812 'g_count',
813 'h_count',
814 'warning' ]
815 if name in none_data:
816 init_data = None
817
818
819 if not hasattr(data, name):
820 setattr(data, name, init_data)
821
822
824 """Function for returning a list of names of data structures.
825
826 Description
827 ~~~~~~~~~~~
828
829 The names are as follows:
830
831 model: The model-free model name.
832
833 equation: The model-free equation type.
834
835 params: An array of the model-free parameter names associated with the model.
836
837 s2: S2.
838
839 s2f: S2f.
840
841 s2s: S2s.
842
843 local_tm: local tm.
844
845 te: te.
846
847 tf: tf.
848
849 ts: ts.
850
851 rex: Rex.
852
853 r: Bond length.
854
855 csa: CSA value.
856
857 chi2: Chi-squared value.
858
859 iter: Iterations.
860
861 f_count: Function count.
862
863 g_count: Gradient count.
864
865 h_count: Hessian count.
866
867 warning: Minimisation warning.
868 """
869
870
871 names = []
872
873
874 if set == 'all' or set == 'generic':
875 names.append('model')
876 names.append('equation')
877 names.append('params')
878
879
880 if set == 'all' or set == 'params':
881 names.append('s2')
882 names.append('s2f')
883 names.append('s2s')
884 names.append('local_tm')
885 names.append('te')
886 names.append('tf')
887 names.append('ts')
888 names.append('rex')
889 names.append('r')
890 names.append('csa')
891
892
893 if set == 'all' or set == 'min':
894 names.append('chi2')
895 names.append('iter')
896 names.append('f_count')
897 names.append('g_count')
898 names.append('h_count')
899 names.append('warning')
900
901 return names
902
903
905 """
906 Model-free default values
907 ~~~~~~~~~~~~~~~~~~~~~~~~~
908
909 _______________________________________________________________________________________
910 | | | |
911 | Data type | Object name | Value |
912 |_______________________________________|____________________|________________________|
913 | | | |
914 | Local tm | 'local_tm' | 10 * 1e-9 |
915 | | | |
916 | Order parameters S2, S2f, and S2s | 's2', 's2f', 's2s' | 0.8 |
917 | | | |
918 | Correlation time te | 'te' | 100 * 1e-12 |
919 | | | |
920 | Correlation time tf | 'tf' | 10 * 1e-12 |
921 | | | |
922 | Correlation time ts | 'ts' | 1000 * 1e-12 |
923 | | | |
924 | Chemical exchange relaxation | 'rex' | 0.0 |
925 | | | |
926 | Bond length | 'r' | 1.02 * 1e-10 |
927 | | | |
928 | CSA | 'csa' | -172 * 1e-6 |
929 |_______________________________________|____________________|________________________|
930
931 """
932
933
934 if param == 'local_tm':
935 return 10.0 * 1e-9
936
937
938 elif search('^S2', param):
939 return 0.8
940
941
942 elif param == 'te':
943 return 100.0 * 1e-12
944
945
946 elif param == 'tf':
947 return 10.0 * 1e-12
948
949
950 elif param == 'ts':
951 return 1000.0 * 1e-12
952
953
954 elif param == 'Rex':
955 return 0.0
956
957
958 elif param == 'r':
959 return 1.02 * 1e-10
960
961
962 elif param == 'CSA':
963 return -172 * 1e-6
964
965
1004
1005
1007 """Determine the type of parameter set."""
1008
1009
1010 if run:
1011 self.run = run
1012
1013
1014 if not self.relax.data.res.has_key(self.run):
1015 raise RelaxNoSequenceError, self.run
1016
1017
1018 local_tm = 0
1019 for i in xrange(len(self.relax.data.res[self.run])):
1020
1021
1022
1023
1024
1025
1026 if not hasattr(self.relax.data.res[self.run][i], 'params') or not self.relax.data.res[self.run][i].params:
1027 continue
1028
1029
1030 if local_tm == 0 and 'local_tm' in self.relax.data.res[self.run][i].params:
1031 local_tm = 1
1032
1033
1034 elif local_tm == 1 and not 'local_tm' in self.relax.data.res[self.run][i].params:
1035 raise RelaxError, "All residues must either have a local tm parameter or not."
1036
1037
1038 mf_all_fixed = 1
1039 for i in xrange(len(self.relax.data.res[self.run])):
1040
1041
1042
1043
1044
1045
1046 if not hasattr(self.relax.data.res[self.run][i], 'fixed'):
1047 mf_all_fixed = 0
1048 break
1049 if not self.relax.data.res[self.run][i].fixed:
1050 mf_all_fixed = 0
1051 break
1052
1053
1054 if local_tm:
1055 return 'local_tm'
1056
1057
1058 if not self.relax.data.diff.has_key(self.run):
1059 raise RelaxNoTensorError, self.run
1060
1061
1062 if mf_all_fixed:
1063
1064 if self.relax.data.diff[self.run].fixed:
1065 raise RelaxError, "All parameters are fixed."
1066
1067 return 'diff'
1068
1069
1070 if self.relax.data.diff[self.run].fixed:
1071 return 'mf'
1072
1073
1074 else:
1075 return 'all'
1076
1077
1079 """Function for disassembling the parameter vector."""
1080
1081
1082 param_index = 0
1083
1084
1085 if sim_index != None and (self.param_set == 'diff' or self.param_set == 'all'):
1086
1087 if self.relax.data.diff[self.run].type == 'sphere':
1088
1089 self.relax.data.diff[self.run].tm_sim[sim_index] = self.param_vector[0]
1090
1091
1092 param_index = param_index + 1
1093
1094
1095 elif self.relax.data.diff[self.run].type == 'spheroid':
1096
1097 self.relax.data.diff[self.run].tm_sim[sim_index] = self.param_vector[0]
1098 self.relax.data.diff[self.run].Da_sim[sim_index] = self.param_vector[1]
1099 self.relax.data.diff[self.run].theta_sim[sim_index] = self.param_vector[2]
1100 self.relax.data.diff[self.run].phi_sim[sim_index] = self.param_vector[3]
1101 self.relax.generic.diffusion_tensor.fold_angles(run=self.run, sim_index=sim_index)
1102
1103
1104 param_index = param_index + 4
1105
1106
1107 elif self.relax.data.diff[self.run].type == 'ellipsoid':
1108
1109 self.relax.data.diff[self.run].tm_sim[sim_index] = self.param_vector[0]
1110 self.relax.data.diff[self.run].Da_sim[sim_index] = self.param_vector[1]
1111 self.relax.data.diff[self.run].Dr_sim[sim_index] = self.param_vector[2]
1112 self.relax.data.diff[self.run].alpha_sim[sim_index] = self.param_vector[3]
1113 self.relax.data.diff[self.run].beta_sim[sim_index] = self.param_vector[4]
1114 self.relax.data.diff[self.run].gamma_sim[sim_index] = self.param_vector[5]
1115 self.relax.generic.diffusion_tensor.fold_angles(run=self.run, sim_index=sim_index)
1116
1117
1118 param_index = param_index + 6
1119
1120
1121 elif self.param_set == 'diff' or self.param_set == 'all':
1122
1123 if self.relax.data.diff[self.run].type == 'sphere':
1124
1125 self.relax.data.diff[self.run].tm = self.param_vector[0]
1126
1127
1128 param_index = param_index + 1
1129
1130
1131 elif self.relax.data.diff[self.run].type == 'spheroid':
1132
1133 self.relax.data.diff[self.run].tm = self.param_vector[0]
1134 self.relax.data.diff[self.run].Da = self.param_vector[1]
1135 self.relax.data.diff[self.run].theta = self.param_vector[2]
1136 self.relax.data.diff[self.run].phi = self.param_vector[3]
1137 self.relax.generic.diffusion_tensor.fold_angles(run=self.run)
1138
1139
1140 param_index = param_index + 4
1141
1142
1143 elif self.relax.data.diff[self.run].type == 'ellipsoid':
1144
1145 self.relax.data.diff[self.run].tm = self.param_vector[0]
1146 self.relax.data.diff[self.run].Da = self.param_vector[1]
1147 self.relax.data.diff[self.run].Dr = self.param_vector[2]
1148 self.relax.data.diff[self.run].alpha = self.param_vector[3]
1149 self.relax.data.diff[self.run].beta = self.param_vector[4]
1150 self.relax.data.diff[self.run].gamma = self.param_vector[5]
1151 self.relax.generic.diffusion_tensor.fold_angles(run=self.run)
1152
1153
1154 param_index = param_index + 6
1155
1156
1157 if self.param_set != 'diff':
1158
1159 for i in xrange(len(self.relax.data.res[self.run])):
1160
1161 data = self.relax.data.res[self.run][i]
1162
1163
1164 if not data.select:
1165 continue
1166
1167
1168 if index != None and i != index:
1169 continue
1170
1171
1172 for j in xrange(len(data.params)):
1173
1174 if data.params[j] == 'local_tm':
1175 if sim_index == None:
1176 data.local_tm = self.param_vector[param_index]
1177 else:
1178 data.local_tm_sim[sim_index] = self.param_vector[param_index]
1179
1180
1181 elif data.params[j] == 'S2':
1182 if sim_index == None:
1183 data.s2 = self.param_vector[param_index]
1184 else:
1185 data.s2_sim[sim_index] = self.param_vector[param_index]
1186
1187
1188 elif data.params[j] == 'S2f':
1189 if sim_index == None:
1190 data.s2f = self.param_vector[param_index]
1191 else:
1192 data.s2f_sim[sim_index] = self.param_vector[param_index]
1193
1194
1195 elif data.params[j] == 'S2s':
1196 if sim_index == None:
1197 data.s2s = self.param_vector[param_index]
1198 else:
1199 data.s2s_sim[sim_index] = self.param_vector[param_index]
1200
1201
1202 elif data.params[j] == 'te':
1203 if sim_index == None:
1204 data.te = self.param_vector[param_index]
1205 else:
1206 data.te_sim[sim_index] = self.param_vector[param_index]
1207
1208
1209 elif data.params[j] == 'tf':
1210 if sim_index == None:
1211 data.tf = self.param_vector[param_index]
1212 else:
1213 data.tf_sim[sim_index] = self.param_vector[param_index]
1214
1215
1216 elif data.params[j] == 'ts':
1217 if sim_index == None:
1218 data.ts = self.param_vector[param_index]
1219 else:
1220 data.ts_sim[sim_index] = self.param_vector[param_index]
1221
1222
1223 elif data.params[j] == 'Rex':
1224 if sim_index == None:
1225 data.rex = self.param_vector[param_index]
1226 else:
1227 data.rex_sim[sim_index] = self.param_vector[param_index]
1228
1229
1230 elif data.params[j] == 'r':
1231 if sim_index == None:
1232 data.r = self.param_vector[param_index]
1233 else:
1234 data.r_sim[sim_index] = self.param_vector[param_index]
1235
1236
1237 elif data.params[j] == 'CSA':
1238 if sim_index == None:
1239 data.csa = self.param_vector[param_index]
1240 else:
1241 data.csa_sim[sim_index] = self.param_vector[param_index]
1242
1243
1244 else:
1245 raise RelaxError, "Unknown parameter."
1246
1247
1248 param_index = param_index + 1
1249
1250
1251 if self.param_set != 'diff':
1252
1253 for i in xrange(len(self.relax.data.res[self.run])):
1254
1255 data = self.relax.data.res[self.run][i]
1256
1257
1258 if not data.select:
1259 continue
1260
1261
1262 if index != None and i != index:
1263 continue
1264
1265
1266 if sim_index == None:
1267
1268 if 'S2' not in data.params and 'S2f' in data.params and 'S2s' in data.params:
1269 data.s2 = data.s2f * data.s2s
1270
1271
1272 if 'S2f' not in data.params and 'S2' in data.params and 'S2s' in data.params:
1273 if data.s2s == 0.0:
1274 data.s2f = 1e99
1275 else:
1276 data.s2f = data.s2 / data.s2s
1277
1278
1279 if 'S2s' not in data.params and 'S2' in data.params and 'S2f' in data.params:
1280 if data.s2f == 0.0:
1281 data.s2s = 1e99
1282 else:
1283 data.s2s = data.s2 / data.s2f
1284
1285
1286 else:
1287
1288 if 'S2' not in data.params and 'S2f' in data.params and 'S2s' in data.params:
1289 data.s2_sim[sim_index] = data.s2f_sim[sim_index] * data.s2s_sim[sim_index]
1290
1291
1292 if 'S2f' not in data.params and 'S2' in data.params and 'S2s' in data.params:
1293 if data.s2s_sim[sim_index] == 0.0:
1294 data.s2f_sim[sim_index] = 1e99
1295 else:
1296 data.s2f_sim[sim_index] = data.s2_sim[sim_index] / data.s2s_sim[sim_index]
1297
1298
1299 if 'S2s' not in data.params and 'S2' in data.params and 'S2f' in data.params:
1300 if data.s2f_sim[sim_index] == 0.0:
1301 data.s2s_sim[sim_index] = 1e99
1302 else:
1303 data.s2s_sim[sim_index] = data.s2_sim[sim_index] / data.s2f_sim[sim_index]
1304
1305
1306 - def duplicate_data(self, new_run=None, old_run=None, instance=None, global_stats=0):
1307 """Function for duplicating data."""
1308
1309
1310 self.run = old_run
1311
1312
1313 for data_name in dir(self.relax.data):
1314
1315 if data_name == 'res':
1316 continue
1317
1318
1319 data = getattr(self.relax.data, data_name)
1320
1321
1322 if not hasattr(data, 'has_key'):
1323 continue
1324
1325
1326 if not data.has_key(old_run):
1327 continue
1328
1329
1330 if data_name != 'pdb' and data_name != 'diff' and data.has_key(new_run) and data[old_run] != data[new_run]:
1331 raise RelaxError, "The data between run " + `new_run` + " and run " + `old_run` + " is not consistent."
1332
1333
1334 if data.has_key(new_run):
1335 continue
1336
1337
1338 data[new_run] = deepcopy(data[old_run])
1339
1340
1341 self.param_set = self.determine_param_set_type()
1342
1343
1344 if self.param_set == 'mf' or (self.param_set == 'local_tm' and not global_stats):
1345
1346 if not self.relax.data.res.has_key(new_run) or not len(self.relax.data.res[new_run]):
1347
1348 self.relax.data.res.add_list(new_run)
1349
1350
1351 for i in xrange(len(self.relax.data.res[old_run])):
1352
1353 self.relax.data.res[new_run].add_item()
1354
1355
1356 self.relax.data.res[new_run][i].num = self.relax.data.res[old_run][i].num
1357 self.relax.data.res[new_run][i].name = self.relax.data.res[old_run][i].name
1358 self.relax.data.res[new_run][i].select = self.relax.data.res[old_run][i].select
1359
1360
1361 self.relax.data.res[new_run][instance] = deepcopy(self.relax.data.res[old_run][instance])
1362
1363
1364 else:
1365
1366 self.relax.data.res[new_run] = deepcopy(self.relax.data.res[old_run])
1367
1368
1369 - def eliminate(self, name, value, run, i, args):
1370 """
1371 Local tm model elimination rule
1372 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1373
1374 The local tm, in some cases, may exceed the value expected for a global correlation time.
1375 Generally the tm value will be stuck at the upper limit defined for the parameter. These
1376 models are eliminated using the rule:
1377
1378 tm >= c
1379
1380 The default value of c is 50 ns, although this can be overridden by supplying the value (in
1381 seconds) as the first element of the args tuple.
1382
1383
1384 Internal correlation times {te, tf, ts} model elimination rules
1385 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1386
1387 These parameters may experience the same problem as the local tm in that the model fails and
1388 the parameter value is stuck at the upper limit. These parameters are constrained using the
1389 formula (te, tf, ts <= 2tm). These failed models are eliminated using the rule:
1390
1391 te, tf, ts >= c . tm
1392
1393 The default value of c is 1.5. Because of round-off errors and the constraint algorithm,
1394 setting c to 2 will result in no models being eliminated as the minimised parameters will
1395 always be less than 2tm. The value can be changed by supplying the value as the second
1396 element of the tuple.
1397
1398
1399 Arguments
1400 ~~~~~~~~~
1401
1402 The 'args' argument must be a tuple of length 2, the elements of which must be numbers. For
1403 example, to eliminate models which have a local tm value greater than 25 ns and models with
1404 internal correlation times greater than 1.5 times tm, set 'args' to (25 * 1e-9, 1.5).
1405 """
1406
1407
1408 c1 = 50.0 * 1e-9
1409 c2 = 1.5
1410
1411
1412 if args != None:
1413 c1, c2 = args
1414
1415
1416 if self.param_set == 'local_tm':
1417 tm = self.relax.data.res[run][i].local_tm
1418 else:
1419 tm = self.relax.data.diff[run].tm
1420
1421
1422 if name == 'local_tm' and value >= c1:
1423 print "The local tm parameter of " + `value` + " is greater than " + `c1` + ", eliminating spin system " + `self.relax.data.res[run][i].num` + " " + self.relax.data.res[run][i].name + " of the run " + `run`
1424 return 1
1425
1426
1427 if match('t[efs]', name) and value >= c2 * tm:
1428 print "The " + name + " value of " + `value` + " is greater than " + `c2 * tm` + ", eliminating spin system " + `self.relax.data.res[run][i].num` + " " + self.relax.data.res[run][i].name + " of the run " + `run`
1429 return 1
1430
1431
1432 return 0
1433
1434
1436 """Function for returning a vector of parameter names."""
1437
1438
1439 self.run = run
1440
1441
1442 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not hasattr(self.relax.data.res[self.run][i], 'relax_error'):
1443 return
1444
1445
1446 for j in xrange(len(self.relax.data.res[self.run])):
1447
1448 if not self.relax.data.res[self.run][j].select:
1449 continue
1450
1451
1452 if not self.relax.data.res[self.run][j].model:
1453 raise RelaxNoModelError, self.run
1454
1455
1456 self.param_set = self.determine_param_set_type()
1457
1458
1459 if self.param_set == 'mf' or self.param_set == 'local_tm':
1460 index = i
1461 else:
1462 index = None
1463
1464
1465 self.assemble_param_names(index=index)
1466
1467
1468 return self.param_names
1469
1470
1472 """Function for returning a vector of parameter values."""
1473
1474
1475 self.run = run
1476
1477
1478 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not hasattr(self.relax.data.res[self.run][i], 'relax_error'):
1479 return
1480
1481
1482 for j in xrange(len(self.relax.data.res[self.run])):
1483
1484 if not self.relax.data.res[self.run][j].select:
1485 continue
1486
1487
1488 if not self.relax.data.res[self.run][j].model:
1489 raise RelaxNoModelError, self.run
1490
1491
1492 self.param_set = self.determine_param_set_type()
1493
1494
1495 if self.param_set == 'mf' or self.param_set == 'local_tm':
1496 index = i
1497 else:
1498 index = None
1499
1500
1501 self.param_vector = self.assemble_param_vector(index=index, sim_index=sim_index)
1502
1503
1504 return self.param_vector
1505
1506
1507 - def grid_search(self, run, lower, upper, inc, constraints, print_flag, sim_index=None):
1508 """The grid search function."""
1509
1510
1511 self.lower = lower
1512 self.upper = upper
1513 self.inc = inc
1514
1515
1516 self.minimise(run=run, min_algor='grid', constraints=constraints, print_flag=print_flag, sim_index=sim_index)
1517
1518
1520 """The grid search setup function."""
1521
1522
1523 n = len(self.param_vector)
1524
1525
1526 if n == 0:
1527 print "Cannot run a grid search on a model with zero parameters, skipping the grid search."
1528
1529
1530 if self.lower != None:
1531 if len(self.lower) != n:
1532 raise RelaxLenError, ('lower bounds', n)
1533
1534
1535 if self.upper != None:
1536 if len(self.upper) != n:
1537 raise RelaxLenError, ('upper bounds', n)
1538
1539
1540 if type(self.inc) == list:
1541 if len(self.inc) != n:
1542 raise RelaxLenError, ('increment', n)
1543 inc = self.inc
1544 elif type(self.inc) == int:
1545 temp = []
1546 for j in xrange(n):
1547 temp.append(self.inc)
1548 inc = temp
1549
1550
1551 min_options = []
1552 m = 0
1553
1554
1555 if self.param_set == 'diff' or self.param_set == 'all':
1556
1557 if self.relax.data.diff[self.run].type == 'sphere':
1558 min_options.append([inc[0], 1.0 * 1e-9, 12.0 * 1e-9])
1559 m = m + 1
1560
1561
1562 if self.relax.data.diff[self.run].type == 'spheroid':
1563 min_options.append([inc[0], 1.0 * 1e-9, 12.0 * 1e-9])
1564 if self.relax.data.diff[self.run].spheroid_type == 'prolate':
1565 min_options.append([inc[1], 0.0, 1e7])
1566 elif self.relax.data.diff[self.run].spheroid_type == 'oblate':
1567 min_options.append([inc[1], -1e7, 0.0])
1568 else:
1569 min_options.append([inc[1], -1e7, 1e7])
1570 min_options.append([inc[2], 0.0, pi])
1571 min_options.append([inc[3], 0.0, pi])
1572 m = m + 4
1573
1574
1575 elif self.relax.data.diff[self.run].type == 'ellipsoid':
1576 min_options.append([inc[0], 1.0 * 1e-9, 12.0 * 1e-9])
1577 min_options.append([inc[1], 0.0, 1e7])
1578 min_options.append([inc[2], 0.0, 1.0])
1579 min_options.append([inc[3], 0.0, pi])
1580 min_options.append([inc[4], 0.0, pi])
1581 min_options.append([inc[5], 0.0, pi])
1582 m = m + 6
1583
1584
1585 if self.param_set != 'diff':
1586 for i in xrange(len(self.relax.data.res[self.run])):
1587
1588 if not self.relax.data.res[self.run][i].select:
1589 continue
1590
1591
1592 if index != None and i != index:
1593 continue
1594
1595
1596 for j in xrange(len(self.relax.data.res[self.run][i].params)):
1597
1598 if self.relax.data.res[self.run][i].params[j] == 'local_tm':
1599 min_options.append([inc[m], 1.0 * 1e-9, 12.0 * 1e-9])
1600
1601
1602 elif match('S2', self.relax.data.res[self.run][i].params[j]):
1603 min_options.append([inc[m], 0.0, 1.0])
1604
1605
1606 elif match('t', self.relax.data.res[self.run][i].params[j]):
1607 min_options.append([inc[m], 0.0, 500.0 * 1e-12])
1608
1609
1610 elif self.relax.data.res[self.run][i].params[j] == 'Rex':
1611 min_options.append([inc[m], 0.0, 5.0 / (2.0 * pi * self.relax.data.res[self.run][i].frq[0])**2])
1612
1613
1614 elif self.relax.data.res[self.run][i].params[j] == 'r':
1615 min_options.append([inc[m], 1.0 * 1e-10, 1.05 * 1e-10])
1616
1617
1618 elif self.relax.data.res[self.run][i].params[j] == 'CSA':
1619 min_options.append([inc[m], -120 * 1e-6, -200 * 1e-6])
1620
1621
1622 else:
1623 raise RelaxError, "Unknown model-free parameter."
1624
1625
1626 m = m + 1
1627
1628
1629 if self.lower != None:
1630 for j in xrange(n):
1631 if self.lower[j] != None:
1632 min_options[j][1] = self.lower[j]
1633 if self.upper != None:
1634 for j in xrange(n):
1635 if self.upper[j] != None:
1636 min_options[j][2] = self.upper[j]
1637
1638
1639 self.grid_size = 1
1640 for i in xrange(len(min_options)):
1641 self.grid_size = self.grid_size * min_options[i][0]
1642 if type(self.grid_size) == long:
1643 raise RelaxError, "A grid search of size " + `self.grid_size` + " is too large."
1644
1645
1646 for j in xrange(len(min_options)):
1647 min_options[j][1] = min_options[j][1] / self.scaling_matrix[j, j]
1648 min_options[j][2] = min_options[j][2] / self.scaling_matrix[j, j]
1649
1650 return min_options
1651
1652
1654 """Function for setting up the model-free linear constraint matrices A and b.
1655
1656 Standard notation
1657 ~~~~~~~~~~~~~~~~~
1658
1659 The order parameter constraints are:
1660
1661 0 <= S2 <= 1
1662 0 <= S2f <= 1
1663 0 <= S2s <= 1
1664
1665 By substituting the formula S2 = S2f.S2s into the above inequalities, the additional two
1666 inequalities can be derived:
1667
1668 S2 <= S2f
1669 S2 <= S2s
1670
1671 Correlation time constraints are:
1672
1673 te >= 0
1674 tf >= 0
1675 ts >= 0
1676
1677 tf <= ts
1678
1679 te, tf, ts <= 2 * tm
1680
1681 Additional constraints used include:
1682
1683 Rex >= 0
1684 0.9e-10 <= r <= 2e-10
1685 -300e-6 <= CSA <= 0
1686
1687
1688 Rearranged notation
1689 ~~~~~~~~~~~~~~~~~~~
1690 The above ineqality constraints can be rearranged into:
1691
1692 S2 >= 0
1693 -S2 >= -1
1694 S2f >= 0
1695 -S2f >= -1
1696 S2s >= 0
1697 -S2s >= -1
1698 S2f - S2 >= 0
1699 S2s - S2 >= 0
1700 te >= 0
1701 tf >= 0
1702 ts >= 0
1703 ts - tf >= 0
1704 Rex >= 0
1705 r >= 0.9e-10
1706 -r >= -2e-10
1707 CSA >= -300e-6
1708 -CSA >= 0
1709
1710
1711 Matrix notation
1712 ~~~~~~~~~~~~~~~
1713
1714 In the notation A.x >= b, where A is an matrix of coefficients, x is an array of parameter
1715 values, and b is a vector of scalars, these inequality constraints are:
1716
1717 | 1 0 0 0 0 0 0 0 0 | | 0 |
1718 | | | |
1719 |-1 0 0 0 0 0 0 0 0 | | -1 |
1720 | | | |
1721 | 0 1 0 0 0 0 0 0 0 | | 0 |
1722 | | | |
1723 | 0 -1 0 0 0 0 0 0 0 | | -1 |
1724 | | | |
1725 | 0 0 1 0 0 0 0 0 0 | | S2 | | 0 |
1726 | | | | | |
1727 | 0 0 -1 0 0 0 0 0 0 | | S2f | | -1 |
1728 | | | | | |
1729 |-1 1 0 0 0 0 0 0 0 | | S2s | | 0 |
1730 | | | | | |
1731 |-1 0 1 0 0 0 0 0 0 | | te | | 0 |
1732 | | | | | |
1733 | 0 0 0 1 0 0 0 0 0 | . | tf | >= | 0 |
1734 | | | | | |
1735 | 0 0 0 0 1 0 0 0 0 | | ts | | 0 |
1736 | | | | | |
1737 | 0 0 0 0 0 1 0 0 0 | | Rex | | 0 |
1738 | | | | | |
1739 | 0 0 0 0 -1 1 0 0 0 | | r | | 0 |
1740 | | | | | |
1741 | 0 0 0 0 0 0 1 0 0 | | CSA | | 0 |
1742 | | | |
1743 | 0 0 0 0 0 0 0 1 0 | | 0.9e-10 |
1744 | | | |
1745 | 0 0 0 0 0 0 0 -1 0 | | -2e-10 |
1746 | | | |
1747 | 0 0 0 0 0 0 0 0 1 | | -300e-6 |
1748 | | | |
1749 | 0 0 0 0 0 0 0 0 -1 | | 0 |
1750
1751 """
1752
1753
1754 upper_time_limit = 1
1755
1756
1757 A = []
1758 b = []
1759 n = len(self.param_vector)
1760 zero_array = zeros(n, Float64)
1761 i = 0
1762 j = 0
1763
1764
1765 if self.param_set != 'mf' and self.relax.data.diff.has_key(self.run):
1766
1767 if self.relax.data.diff[self.run].type == 'sphere':
1768
1769 A.append(zero_array * 0.0)
1770 A.append(zero_array * 0.0)
1771 A[j][i] = 1.0
1772 A[j+1][i] = -1.0
1773 b.append(0.0 / self.scaling_matrix[i, i])
1774 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i])
1775 i = i + 1
1776 j = j + 2
1777
1778
1779 elif self.relax.data.diff[self.run].type == 'spheroid':
1780
1781 A.append(zero_array * 0.0)
1782 A.append(zero_array * 0.0)
1783 A[j][i] = 1.0
1784 A[j+1][i] = -1.0
1785 b.append(0.0 / self.scaling_matrix[i, i])
1786 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i])
1787 i = i + 1
1788 j = j + 2
1789
1790
1791 if self.relax.data.diff[self.run].spheroid_type == 'prolate':
1792 A.append(zero_array * 0.0)
1793 A[j][i] = 1.0
1794 b.append(0.0 / self.scaling_matrix[i, i])
1795 i = i + 1
1796 j = j + 1
1797
1798
1799 i = i + 2
1800
1801
1802 elif self.relax.data.diff[self.run].spheroid_type == 'oblate':
1803 A.append(zero_array * 0.0)
1804 A[j][i] = -1.0
1805 b.append(0.0 / self.scaling_matrix[i, i])
1806 i = i + 1
1807 j = j + 1
1808
1809
1810 i = i + 2
1811
1812 else:
1813
1814 i = i + 3
1815
1816
1817 elif self.relax.data.diff[self.run].type == 'ellipsoid':
1818
1819 A.append(zero_array * 0.0)
1820 A.append(zero_array * 0.0)
1821 A[j][i] = 1.0
1822 A[j+1][i] = -1.0
1823 b.append(0.0 / self.scaling_matrix[i, i])
1824 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i])
1825 i = i + 1
1826 j = j + 2
1827
1828
1829 A.append(zero_array * 0.0)
1830 A[j][i] = 1.0
1831 b.append(0.0 / self.scaling_matrix[i, i])
1832 i = i + 1
1833 j = j + 1
1834
1835
1836 A.append(zero_array * 0.0)
1837 A.append(zero_array * 0.0)
1838 A[j][i] = 1.0
1839 A[j+1][i] = -1.0
1840 b.append(0.0 / self.scaling_matrix[i, i])
1841 b.append(-1.0 / self.scaling_matrix[i, i])
1842 i = i + 1
1843 j = j + 2
1844
1845
1846 i = i + 3
1847
1848
1849 if self.param_set != 'diff':
1850
1851 for k in xrange(len(self.relax.data.res[self.run])):
1852
1853 if not self.relax.data.res[self.run][k].select:
1854 continue
1855
1856
1857 if index != None and k != index:
1858 continue
1859
1860
1861 old_i = i
1862
1863
1864 for l in xrange(len(self.relax.data.res[self.run][k].params)):
1865
1866 if self.relax.data.res[self.run][k].params[l] == 'local_tm':
1867 if upper_time_limit:
1868
1869 A.append(zero_array * 0.0)
1870 A.append(zero_array * 0.0)
1871 A[j][i] = 1.0
1872 A[j+1][i] = -1.0
1873 b.append(0.0 / self.scaling_matrix[i, i])
1874 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i])
1875 j = j + 2
1876 else:
1877
1878 A.append(zero_array * 0.0)
1879 A[j][i] = 1.0
1880 b.append(0.0 / self.scaling_matrix[i, i])
1881 j = j + 1
1882
1883
1884 elif match('S2', self.relax.data.res[self.run][k].params[l]):
1885
1886 A.append(zero_array * 0.0)
1887 A.append(zero_array * 0.0)
1888 A[j][i] = 1.0
1889 A[j+1][i] = -1.0
1890 b.append(0.0 / self.scaling_matrix[i, i])
1891 b.append(-1.0 / self.scaling_matrix[i, i])
1892 j = j + 2
1893
1894
1895 if self.relax.data.res[self.run][k].params[l] == 'S2':
1896 for m in xrange(len(self.relax.data.res[self.run][k].params)):
1897 if self.relax.data.res[self.run][k].params[m] == 'S2f' or self.relax.data.res[self.run][k].params[m] == 'S2s':
1898 A.append(zero_array * 0.0)
1899 A[j][i] = -1.0
1900 A[j][old_i+m] = 1.0
1901 b.append(0.0)
1902 j = j + 1
1903
1904
1905 elif match('t[efs]', self.relax.data.res[self.run][k].params[l]):
1906
1907 A.append(zero_array * 0.0)
1908 A[j][i] = 1.0
1909 b.append(0.0 / self.scaling_matrix[i, i])
1910 j = j + 1
1911
1912
1913 if self.relax.data.res[self.run][k].params[l] == 'ts':
1914 for m in xrange(len(self.relax.data.res[self.run][k].params)):
1915 if self.relax.data.res[self.run][k].params[m] == 'tf':
1916 A.append(zero_array * 0.0)
1917 A[j][i] = 1.0
1918 A[j][old_i+m] = -1.0
1919 b.append(0.0)
1920 j = j + 1
1921
1922
1923 if upper_time_limit:
1924 if not self.relax.data.res[self.run][k].params[l] == 'tf':
1925 if self.param_set == 'mf':
1926 A.append(zero_array * 0.0)
1927 A[j][i] = -1.0
1928 b.append(-2.0 * self.relax.data.diff[self.run].tm / self.scaling_matrix[i, i])
1929 else:
1930 A.append(zero_array * 0.0)
1931 A[j][0] = 2.0
1932 A[j][i] = -1.0
1933 b.append(0.0)
1934
1935 j = j + 1
1936
1937
1938 elif self.relax.data.res[self.run][k].params[l] == 'Rex':
1939 A.append(zero_array * 0.0)
1940 A[j][i] = 1.0
1941 b.append(0.0 / self.scaling_matrix[i, i])
1942 j = j + 1
1943
1944
1945 elif self.relax.data.res[self.run][k].params[l] == 'r':
1946
1947 A.append(zero_array * 0.0)
1948 A.append(zero_array * 0.0)
1949 A[j][i] = 1.0
1950 A[j+1][i] = -1.0
1951 b.append(0.9e-10 / self.scaling_matrix[i, i])
1952 b.append(-2e-10 / self.scaling_matrix[i, i])
1953 j = j + 2
1954
1955
1956 elif self.relax.data.res[self.run][k].params[l] == 'CSA':
1957
1958 A.append(zero_array * 0.0)
1959 A.append(zero_array * 0.0)
1960 A[j][i] = 1.0
1961 A[j+1][i] = -1.0
1962 b.append(-300e-6 / self.scaling_matrix[i, i])
1963 b.append(0.0 / self.scaling_matrix[i, i])
1964 j = j + 2
1965
1966
1967 i = i + 1
1968
1969
1970 A = array(A, Float64)
1971 b = array(b, Float64)
1972
1973 return A, b
1974
1975
1977 """The function for creating bounds for the mapping function."""
1978
1979
1980 self.run = run
1981
1982
1983 if search('^s2', param):
1984 return [0, 1]
1985
1986
1987 elif search('^t', param) or param == 'local_tm':
1988 return [0, 1e-8]
1989
1990
1991 elif param == 'rex':
1992 return [0, 30.0 / (2.0 * pi * self.relax.data.frq[self.run][0])**2]
1993
1994
1995 elif param == 'r':
1996 return [1.0 * 1e-10, 1.1 * 1e-10]
1997
1998
1999 elif param == 'csa':
2000 return [-100 * 1e-6, -300 * 1e-6]
2001
2002
2003 - def minimise(self, run=None, min_algor=None, min_options=None, func_tol=None, grad_tol=None, max_iterations=None, constraints=0, scaling=1, print_flag=0, sim_index=None):
2004 """Model-free minimisation.
2005
2006 Three types of parameter sets exist for which minimisation is different. These are:
2007 'mf' - Model-free parameters for single residues.
2008 'diff' - Diffusion tensor parameters.
2009 'all' - All model-free and all diffusion tensor parameters.
2010 """
2011
2012
2013 self.run = run
2014 self.print_flag = print_flag
2015
2016
2017 if not self.relax.data.res.has_key(self.run):
2018 raise RelaxNoSequenceError, self.run
2019
2020
2021 for i in xrange(len(self.relax.data.res[self.run])):
2022
2023 if not self.relax.data.res[self.run][i].select:
2024 continue
2025
2026
2027 if not self.relax.data.res[self.run][i].model:
2028 raise RelaxNoModelError, self.run
2029
2030
2031 self.param_set = self.determine_param_set_type()
2032
2033
2034 if min_algor == 'back_calc' and self.param_set != 'local_tm':
2035 self.param_set = 'mf'
2036
2037
2038 if self.param_set != 'local_tm' and not self.relax.data.diff.has_key(self.run):
2039 raise RelaxNoTensorError, self.run
2040
2041
2042 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'sphere':
2043
2044 if not self.relax.data.pdb.has_key(self.run):
2045 raise RelaxNoPdbError, self.run
2046
2047
2048 for i in xrange(len(self.relax.data.res[self.run])):
2049
2050 if not self.relax.data.res[self.run][i].select:
2051 continue
2052
2053
2054 if not hasattr(self.relax.data.res[self.run][i], 'xh_vect'):
2055 raise RelaxNoVectorsError, self.run
2056
2057
2058 if not hasattr(self.relax.data, 'gx'):
2059 raise RelaxNucleusError
2060
2061
2062 if self.param_set == 'diff':
2063
2064 for i in xrange(len(self.relax.data.res[self.run])):
2065 unset_param = self.are_mf_params_set(i)
2066 if unset_param != None:
2067 raise RelaxNoValueError, unset_param
2068
2069
2070 if self.print_flag >= 1:
2071 if self.param_set == 'mf':
2072 print "Only the model-free parameters for single residues will be used."
2073 elif self.param_set == 'local_mf':
2074 print "Only a local tm value together with the model-free parameters for single residues will be used."
2075 elif self.param_set == 'diff':
2076 print "Only diffusion tensor parameters will be used."
2077 elif self.param_set == 'all':
2078 print "The diffusion tensor parameters together with the model-free parameters for all residues will be used."
2079
2080
2081 num_res = 0
2082 for i in xrange(len(self.relax.data.res[self.run])):
2083
2084 if not self.relax.data.res[self.run][i].select:
2085 continue
2086
2087
2088 if not hasattr(self.relax.data.res[self.run][i], 'csa') or self.relax.data.res[self.run][i].csa == None:
2089 raise RelaxNoValueError, "CSA"
2090
2091
2092 if not hasattr(self.relax.data.res[self.run][i], 'r') or self.relax.data.res[self.run][i].r == None:
2093 raise RelaxNoValueError, "bond length"
2094
2095
2096 num_res = num_res + 1
2097
2098
2099 if self.param_set == 'mf' or self.param_set == 'local_tm':
2100 num_instances = len(self.relax.data.res[self.run])
2101 num_data_sets = 1
2102 num_res = 1
2103 elif self.param_set == 'diff' or self.param_set == 'all':
2104 num_instances = 1
2105 num_data_sets = len(self.relax.data.res[self.run])
2106
2107
2108 if min_algor == 'back_calc':
2109 num_instances = 1
2110 num_data_sets = 0
2111 num_res = 1
2112
2113
2114
2115
2116
2117 for i in xrange(num_instances):
2118
2119 if min_algor == 'back_calc':
2120 index = min_options[0]
2121 else:
2122 index = i
2123
2124
2125 if self.param_set == 'diff' or self.param_set == 'all':
2126 index = None
2127
2128
2129 if (self.param_set == 'mf' or self.param_set == 'local_tm') and not min_algor == 'back_calc':
2130
2131 if not self.relax.data.res[self.run][i].select:
2132 continue
2133
2134
2135 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not hasattr(self.relax.data.res[self.run][i], 'relax_error'):
2136 continue
2137
2138
2139 if min_algor == 'back_calc':
2140
2141 self.param_vector = self.assemble_param_vector(index=index)
2142
2143
2144 self.scaling_matrix = None
2145
2146 else:
2147
2148 self.param_vector = self.assemble_param_vector(index=index, sim_index=sim_index)
2149
2150
2151 self.assemble_scaling_matrix(index=index, scaling=scaling)
2152 if self.scaling_matrix:
2153 self.param_vector = matrixmultiply(inverse(self.scaling_matrix), self.param_vector)
2154
2155
2156 if match('^[Gg]rid', min_algor):
2157 min_options = self.grid_search_setup(index=index)
2158
2159
2160 if match('^[Ss]et', min_algor):
2161 min_options = matrixmultiply(inverse(self.scaling_matrix), min_options)
2162
2163
2164 if constraints:
2165 A, b = self.linear_constraints(index=index)
2166
2167
2168 if self.print_flag >= 1:
2169
2170 if self.param_set == 'mf' or self.param_set == 'local_tm':
2171 if self.print_flag >= 2:
2172 print "\n\n"
2173 string = "Fitting to residue: " + `self.relax.data.res[self.run][index].num` + " " + self.relax.data.res[self.run][index].name
2174 print "\n\n" + string
2175 print len(string) * '~'
2176 if match('^[Gg]rid', min_algor):
2177 print "Unconstrained grid search size: " + `self.grid_size` + " (constraints may decrease this size).\n"
2178
2179
2180 self.iter_count = 0
2181 self.f_count = 0
2182 self.g_count = 0
2183 self.h_count = 0
2184
2185
2186 relax_data = []
2187 relax_error = []
2188 equations = []
2189 param_types = []
2190 param_values = None
2191 r = []
2192 csa = []
2193 num_frq = []
2194 frq = []
2195 num_ri = []
2196 remap_table = []
2197 noe_r1_table = []
2198 ri_labels = []
2199 num_params = []
2200 xh_unit_vectors = []
2201 if self.param_set == 'local_tm':
2202 mf_params = []
2203 elif self.param_set == 'diff':
2204 param_values = []
2205
2206
2207 if min_algor == 'back_calc':
2208
2209 relax_data = [0.0]
2210 relax_error = [0.000001]
2211 equations = [self.relax.data.res[self.run][index].equation]
2212 param_types = [self.relax.data.res[self.run][index].params]
2213 r = [self.relax.data.res[self.run][index].r]
2214 csa = [self.relax.data.res[self.run][index].csa]
2215 num_frq = [1]
2216 frq = [[min_options[3]]]
2217 num_ri = [1]
2218 remap_table = [[0]]
2219 noe_r1_table = [[None]]
2220 ri_labels = [[min_options[1]]]
2221 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'sphere':
2222 xh_unit_vectors = [self.relax.data.res[self.run][index].xh_vect]
2223 else:
2224 xh_unit_vectors = [None]
2225
2226
2227 num_params = [len(self.relax.data.res[self.run][index].params)]
2228
2229
2230 for j in xrange(num_data_sets):
2231
2232 if self.param_set == 'mf' or self.param_set == 'local_tm':
2233 seq_index = i
2234 else:
2235 seq_index = j
2236
2237
2238 data = self.relax.data.res[self.run][seq_index]
2239
2240
2241 if not data.select:
2242 continue
2243
2244
2245 if not hasattr(data, 'relax_data') or not hasattr(data, 'relax_error'):
2246 continue
2247
2248
2249 for k in xrange(len(data.relax_error)):
2250 if data.relax_error[k] == 0.0:
2251 raise RelaxError, "Zero error for residue '" + `data.num` + " " + data.name + "', minimisation not possible."
2252 elif data.relax_error[k] < 0.0:
2253 raise RelaxError, "Negative error for residue '" + `data.num` + " " + data.name + "', minimisation not possible."
2254
2255
2256 if sim_index == None:
2257 relax_data.append(data.relax_data)
2258 else:
2259 relax_data.append(data.relax_sim_data[sim_index])
2260 relax_error.append(data.relax_error)
2261 equations.append(data.equation)
2262 param_types.append(data.params)
2263 num_frq.append(data.num_frq)
2264 frq.append(data.frq)
2265 num_ri.append(data.num_ri)
2266 remap_table.append(data.remap_table)
2267 noe_r1_table.append(data.noe_r1_table)
2268 ri_labels.append(data.ri_labels)
2269 if sim_index == None or self.param_set == 'diff':
2270 r.append(data.r)
2271 csa.append(data.csa)
2272 else:
2273 r.append(data.r_sim[sim_index])
2274 csa.append(data.csa_sim[sim_index])
2275
2276
2277 if self.param_set == 'local_tm':
2278 pass
2279
2280
2281 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'sphere':
2282 xh_unit_vectors.append(data.xh_vect)
2283 else:
2284 xh_unit_vectors.append(None)
2285
2286
2287 num_params.append(len(data.params))
2288
2289
2290 if self.param_set == 'diff':
2291 param_values.append(self.assemble_param_vector(param_set='mf'))
2292
2293
2294 for k in xrange(len(relax_data)):
2295 relax_data[k] = array(relax_data[k], Float64)
2296 relax_error[k] = array(relax_error[k], Float64)
2297
2298
2299 if self.param_set == 'local_tm':
2300 diff_type = 'sphere'
2301 else:
2302 diff_type = self.relax.data.diff[self.run].type
2303
2304
2305 diff_params = None
2306 if self.param_set == 'mf':
2307
2308 data = self.relax.data.diff[self.run]
2309
2310
2311 if diff_type == 'sphere':
2312 diff_params = [data.tm]
2313
2314
2315 elif diff_type == 'spheroid':
2316 diff_params = [data.tm, data.Da, data.theta, data.phi]
2317
2318
2319 elif diff_type == 'ellipsoid':
2320 diff_params = [data.tm, data.Da, data.Dr, data.alpha, data.beta, data.gamma]
2321 elif min_algor == 'back_calc' and self.param_set == 'local_tm':
2322
2323 diff_params = [self.relax.data.res[self.run][index].local_tm]
2324
2325
2326
2327
2328
2329
2330 self.mf = Mf(init_params=self.param_vector, param_set=self.param_set, diff_type=diff_type, diff_params=diff_params, scaling_matrix=self.scaling_matrix, num_res=num_res, equations=equations, param_types=param_types, param_values=param_values, relax_data=relax_data, errors=relax_error, bond_length=r, csa=csa, num_frq=num_frq, frq=frq, num_ri=num_ri, remap_table=remap_table, noe_r1_table=noe_r1_table, ri_labels=ri_labels, gx=self.relax.data.gx, gh=self.relax.data.gh, g_ratio=self.relax.data.g_ratio, h_bar=self.relax.data.h_bar, mu0=self.relax.data.mu0, num_params=num_params, vectors=xh_unit_vectors)
2331
2332
2333
2334
2335
2336 if constraints and not match('^[Gg]rid', min_algor):
2337 algor = min_options[0]
2338 else:
2339 algor = min_algor
2340
2341
2342
2343
2344
2345 if match('[Ll][Mm]$', algor) or match('[Ll]evenburg-[Mm]arquardt$', algor):
2346
2347 number_ri = 0
2348 for k in xrange(len(relax_error)):
2349 number_ri = number_ri + len(relax_error[k])
2350
2351
2352 lm_error = zeros(number_ri, Float64)
2353 index = 0
2354 for k in xrange(len(relax_error)):
2355 lm_error[index:index+len(relax_error[k])] = relax_error[k]
2356 index = index + len(relax_error[k])
2357
2358 min_options = min_options + (self.mf.lm_dri, lm_error)
2359
2360
2361
2362
2363
2364 if min_algor == 'back_calc':
2365 return self.mf.calc_ri()
2366
2367
2368
2369
2370
2371 if constraints:
2372 results = generic_minimise(func=self.mf.func, dfunc=self.mf.dfunc, d2func=self.mf.d2func, args=(), x0=self.param_vector, min_algor=min_algor, min_options=min_options, func_tol=func_tol, grad_tol=grad_tol, maxiter=max_iterations, A=A, b=b, full_output=1, print_flag=print_flag)
2373 else:
2374 results = generic_minimise(func=self.mf.func, dfunc=self.mf.dfunc, d2func=self.mf.d2func, args=(), x0=self.param_vector, min_algor=min_algor, min_options=min_options, func_tol=func_tol, grad_tol=grad_tol, maxiter=max_iterations, full_output=1, print_flag=print_flag)
2375 if results == None:
2376 continue
2377 self.param_vector, self.func, iter, fc, gc, hc, self.warning = results
2378 self.iter_count = self.iter_count + iter
2379 self.f_count = self.f_count + fc
2380 self.g_count = self.g_count + gc
2381 self.h_count = self.h_count + hc
2382
2383
2384 if isInf(self.func):
2385 raise RelaxInfError, 'chi-squared'
2386
2387
2388 if isNaN(self.func):
2389 raise RelaxNaNError, 'chi-squared'
2390
2391
2392 if scaling:
2393 self.param_vector = matrixmultiply(self.scaling_matrix, self.param_vector)
2394
2395
2396 self.disassemble_param_vector(index=index, sim_index=sim_index)
2397
2398
2399 if sim_index != None:
2400
2401 if self.param_set == 'mf' or self.param_set == 'local_tm':
2402
2403 self.relax.data.res[self.run][i].chi2_sim[sim_index] = self.func
2404
2405
2406 self.relax.data.res[self.run][i].iter_sim[sim_index] = self.iter_count
2407
2408
2409 self.relax.data.res[self.run][i].f_count_sim[sim_index] = self.f_count
2410
2411
2412 self.relax.data.res[self.run][i].g_count_sim[sim_index] = self.g_count
2413
2414
2415 self.relax.data.res[self.run][i].h_count_sim[sim_index] = self.h_count
2416
2417
2418 self.relax.data.res[self.run][i].warning_sim[sim_index] = self.warning
2419
2420
2421 elif self.param_set == 'diff' or self.param_set == 'all':
2422
2423 self.relax.data.chi2_sim[self.run][sim_index] = self.func
2424
2425
2426 self.relax.data.iter_sim[self.run][sim_index] = self.iter_count
2427
2428
2429 self.relax.data.f_count_sim[self.run][sim_index] = self.f_count
2430
2431
2432 self.relax.data.g_count_sim[self.run][sim_index] = self.g_count
2433
2434
2435 self.relax.data.h_count_sim[self.run][sim_index] = self.h_count
2436
2437
2438 self.relax.data.warning_sim[self.run][sim_index] = self.warning
2439
2440
2441 else:
2442
2443 if self.param_set == 'mf' or self.param_set == 'local_tm':
2444
2445 self.relax.data.res[self.run][i].chi2 = self.func
2446
2447
2448 self.relax.data.res[self.run][i].iter = self.iter_count
2449
2450
2451 self.relax.data.res[self.run][i].f_count = self.f_count
2452
2453
2454 self.relax.data.res[self.run][i].g_count = self.g_count
2455
2456
2457 self.relax.data.res[self.run][i].h_count = self.h_count
2458
2459
2460 self.relax.data.res[self.run][i].warning = self.warning
2461
2462
2463 elif self.param_set == 'diff' or self.param_set == 'all':
2464
2465 self.relax.data.chi2[self.run] = self.func
2466
2467
2468 self.relax.data.iter[self.run] = self.iter_count
2469
2470
2471 self.relax.data.f_count[self.run] = self.f_count
2472
2473
2474 self.relax.data.g_count[self.run] = self.g_count
2475
2476
2477 self.relax.data.h_count[self.run] = self.h_count
2478
2479
2480 self.relax.data.warning[self.run] = self.warning
2481
2482
2483 - def model_setup(self, run=None, model=None, equation=None, params=None, res_num=None):
2484 """Function for updating various data structures depending on the model selected."""
2485
2486
2487 if params:
2488 for param in params:
2489 if param == 'local_tm' and self.relax.data.diff.has_key(run):
2490 raise RelaxTensorError, run
2491
2492
2493 for i in xrange(len(self.relax.data.res[run])):
2494
2495 if res_num != None and res_num != self.relax.data.res[run][i].num:
2496 continue
2497
2498
2499 self.data_init(self.relax.data.res[run][i])
2500
2501
2502 if model:
2503 self.relax.data.res[run][i].model = model
2504 if equation:
2505 self.relax.data.res[run][i].equation = equation
2506 if params:
2507 self.relax.data.res[run][i].params = params
2508
2509
2511 """Function for returning k, n, and chi2.
2512
2513 k - number of parameters.
2514 n - number of data points.
2515 chi2 - the chi-squared value.
2516 """
2517
2518
2519 self.run = run
2520
2521
2522 if global_stats == None:
2523 global_stats = 1
2524 for i in xrange(len(self.relax.data.res[self.run])):
2525 if hasattr(self.relax.data.res[self.run][i], 'chi2') and self.relax.data.res[self.run][i].chi2 != None:
2526 global_stats = 0
2527 break
2528
2529
2530 self.param_set = self.determine_param_set_type()
2531
2532
2533 if not global_stats:
2534
2535 if not self.relax.data.res[self.run][instance].select:
2536 return None, None, None
2537
2538
2539 if not hasattr(self.relax.data.res[self.run][instance], 'relax_data'):
2540 return None, None, None
2541
2542
2543 self.param_vector = self.assemble_param_vector(index=instance)
2544 k = len(self.param_vector)
2545
2546
2547 n = len(self.relax.data.res[self.run][instance].relax_data)
2548
2549
2550 chi2 = self.relax.data.res[self.run][instance].chi2
2551
2552
2553 elif global_stats:
2554
2555 self.param_vector = self.assemble_param_vector()
2556 k = len(self.param_vector)
2557
2558
2559 n = 0
2560 chi2 = 0
2561 for i in xrange(len(self.relax.data.res[self.run])):
2562
2563 if not self.relax.data.res[self.run][i].select:
2564 continue
2565
2566
2567 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not len(self.relax.data.res[self.run][i].relax_data):
2568 continue
2569
2570 n = n + len(self.relax.data.res[self.run][i].relax_data)
2571
2572
2573 if self.param_set == 'local_tm':
2574 chi2 = chi2 + self.relax.data.res[self.run][i].chi2
2575
2576
2577 if self.param_set != 'local_tm':
2578 chi2 = self.relax.data.chi2[self.run]
2579
2580
2581 return k, n, chi2
2582
2583
2585 """Function for returning the number of instances."""
2586
2587
2588 self.run = run
2589
2590
2591 if not self.relax.data.res.has_key(self.run):
2592 return 0
2593
2594
2595 self.param_set = self.determine_param_set_type()
2596
2597
2598 if self.param_set == 'mf' or self.param_set == 'local_tm':
2599 return len(self.relax.data.res[self.run])
2600
2601
2602 elif self.param_set == 'diff' or self.param_set == 'all':
2603 return 1
2604
2605
2606 else:
2607 raise RelaxFault
2608
2609
2611 """Function for deselecting residues without sufficient data to support minimisation"""
2612
2613
2614 if not self.relax.data.res.has_key(run):
2615 raise RelaxNoSequenceError, run
2616
2617
2618 for residue in self.relax.data.res[run]:
2619
2620 if not residue.select:
2621 continue
2622
2623
2624 if not hasattr(residue, 'relax_data'):
2625 residue.select = 0
2626 continue
2627
2628
2629 if len(residue.relax_data) < 3:
2630 residue.select = 0
2631 continue
2632
2633
2634 if hasattr(residue, 'params'):
2635 if len(residue.params) > len(residue.relax_data):
2636 residue.select = 0
2637 continue
2638
2639
2640 if hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(run):
2641 if self.relax.data.diff[run].type == 'spheroid' or self.relax.data.diff[run].type == 'ellipsoid':
2642 if not hasattr(residue, 'xh_vect'):
2643 residue.select = 0
2644 continue
2645
2646
2648 """Function for sorting the column numbers from the columnar formatted results file."""
2649
2650
2651 self.col = {}
2652
2653
2654 for i in xrange(len(header)):
2655
2656 if header[i] == 'Num':
2657 self.col['num'] = i
2658 elif header[i] == 'Name':
2659 self.col['name'] = i
2660 elif header[i] == 'Selected':
2661 self.col['select'] = i
2662 elif header[i] == 'Data_set':
2663 self.col['data_set'] = i
2664 elif header[i] == 'Nucleus':
2665 self.col['nucleus'] = i
2666 elif header[i] == 'Model':
2667 self.col['model'] = i
2668 elif header[i] == 'Equation':
2669 self.col['eqi'] = i
2670 elif header[i] == 'Params':
2671 self.col['params'] = i
2672 elif header[i] == 'Param_set':
2673 self.col['param_set'] = i
2674
2675
2676 elif header[i] == 'S2':
2677 self.col['s2'] = i
2678 elif header[i] == 'S2f':
2679 self.col['s2f'] = i
2680 elif header[i] == 'S2s':
2681 self.col['s2s'] = i
2682 elif search('^Local_tm', header[i]):
2683 self.col['local_tm'] = i
2684 elif search('^te', header[i]):
2685 self.col['te'] = i
2686 elif search('^tf', header[i]):
2687 self.col['tf'] = i
2688 elif search('^ts', header[i]):
2689 self.col['ts'] = i
2690 elif search('^Rex', header[i]):
2691 self.col['rex'] = i
2692 elif search('^Bond_length', header[i]):
2693 self.col['r'] = i
2694 elif search('^CSA', header[i]):
2695 self.col['csa'] = i
2696
2697
2698 elif header[i] == 'Chi-squared':
2699 self.col['chi2'] = i
2700 elif header[i] == 'Iter':
2701 self.col['iter'] = i
2702 elif header[i] == 'f_count':
2703 self.col['f_count'] = i
2704 elif header[i] == 'g_count':
2705 self.col['g_count'] = i
2706 elif header[i] == 'h_count':
2707 self.col['h_count'] = i
2708 elif header[i] == 'Warning':
2709 self.col['warn'] = i
2710
2711
2712 elif header[i] == 'Diff_type':
2713 self.col['diff_type'] = i
2714 elif header[i] == 'tm_(s)':
2715 self.col['tm'] = i
2716 elif header[i] == 'Da_(1/s)':
2717 self.col['da'] = i
2718 elif header[i] == 'theta_(deg)':
2719 self.col['theta'] = i
2720 elif header[i] == 'phi_(deg)':
2721 self.col['phi'] = i
2722 elif header[i] == 'Da_(1/s)':
2723 self.col['da'] = i
2724 elif header[i] == 'Dr_(1/s)':
2725 self.col['dr'] = i
2726 elif header[i] == 'alpha_(deg)':
2727 self.col['alpha'] = i
2728 elif header[i] == 'beta_(deg)':
2729 self.col['beta'] = i
2730 elif header[i] == 'gamma_(deg)':
2731 self.col['gamma'] = i
2732
2733
2734 elif header[i] == 'PDB':
2735 self.col['pdb'] = i
2736 elif header[i] == 'PDB_model':
2737 self.col['pdb_model'] = i
2738 elif header[i] == 'PDB_heteronuc':
2739 self.col['pdb_heteronuc'] = i
2740 elif header[i] == 'PDB_proton':
2741 self.col['pdb_proton'] = i
2742 elif header[i] == 'XH_vector':
2743 self.col['xh_vect'] = i
2744
2745
2746 elif header[i] == 'Ri_labels':
2747 self.col['ri_labels'] = i
2748 elif header[i] == 'Remap_table':
2749 self.col['remap_table'] = i
2750 elif header[i] == 'Frq_labels':
2751 self.col['frq_labels'] = i
2752 elif header[i] == 'Frequencies':
2753 self.col['frq'] = i
2754
2755
2757 """Function for setting up the diffusion tensor from the columnar formatted results file."""
2758
2759
2760 diff_type = self.file_line[self.col['diff_type']]
2761 if diff_type == 'None':
2762 diff_type = None
2763
2764
2765 if diff_type == 'sphere':
2766
2767 try:
2768 tm = float(self.file_line[self.col['tm']])
2769 except ValueError:
2770
2771 if self.data_set != 'value' and self.file_line[self.col['tm']] == 'None':
2772 return
2773
2774
2775 raise RelaxError, "The diffusion tensor parameters are not numbers."
2776
2777
2778 if self.data_set == 'value':
2779 diff_params = tm
2780
2781
2782 elif self.data_set == 'error':
2783 self.relax.data.diff[self.run].tm_err = tm
2784
2785
2786 else:
2787
2788 if not hasattr(self.relax.data.diff[self.run], 'tm_sim'):
2789 self.relax.data.diff[self.run].tm_sim = []
2790
2791
2792 self.relax.data.diff[self.run].tm_sim.append(tm)
2793
2794
2795
2796 elif diff_type == 'spheroid' or diff_type == 'oblate' or diff_type == 'prolate':
2797
2798 try:
2799 tm = float(self.file_line[self.col['tm']])
2800 Da = float(self.file_line[self.col['da']])
2801 theta = float(self.file_line[self.col['theta']]) / 360.0 * 2.0 * pi
2802 phi = float(self.file_line[self.col['phi']]) / 360.0 * 2.0 * pi
2803 except ValueError:
2804
2805 if self.data_set != 'value' and self.file_line[self.col['tm']] == 'None':
2806 return
2807
2808
2809 raise RelaxError, "The diffusion tensor parameters are not numbers."
2810
2811
2812 if self.data_set == 'value':
2813 diff_params = [tm, Da, theta, phi]
2814
2815
2816 elif self.data_set == 'error':
2817 self.relax.data.diff[self.run].tm_err = tm
2818 self.relax.data.diff[self.run].Da_err = Da
2819 self.relax.data.diff[self.run].theta_err = theta
2820 self.relax.data.diff[self.run].phi_err = phi
2821
2822
2823 else:
2824
2825 if not hasattr(self.relax.data.diff[self.run], 'tm_sim'):
2826 self.relax.data.diff[self.run].tm_sim = []
2827 if not hasattr(self.relax.data.diff[self.run], 'Da_sim'):
2828 self.relax.data.diff[self.run].Da_sim = []
2829 if not hasattr(self.relax.data.diff[self.run], 'theta_sim'):
2830 self.relax.data.diff[self.run].theta_sim = []
2831 if not hasattr(self.relax.data.diff[self.run], 'phi_sim'):
2832 self.relax.data.diff[self.run].phi_sim = []
2833
2834
2835 self.relax.data.diff[self.run].tm_sim.append(tm)
2836 self.relax.data.diff[self.run].Da_sim.append(Da)
2837 self.relax.data.diff[self.run].theta_sim.append(theta)
2838 self.relax.data.diff[self.run].phi_sim.append(phi)
2839
2840
2841
2842 elif diff_type == 'ellipsoid':
2843
2844 try:
2845 tm = float(self.file_line[self.col['tm']])
2846 Da = float(self.file_line[self.col['da']])
2847 Dr = float(self.file_line[self.col['dr']])
2848 alpha = float(self.file_line[self.col['alpha']]) / 360.0 * 2.0 * pi
2849 beta = float(self.file_line[self.col['beta']]) / 360.0 * 2.0 * pi
2850 gamma = float(self.file_line[self.col['gamma']]) / 360.0 * 2.0 * pi
2851 except ValueError:
2852
2853 if self.data_set != 'value' and self.file_line[self.col['tm']] == 'None':
2854 return
2855
2856
2857 raise RelaxError, "The diffusion tensor parameters are not numbers."
2858
2859
2860 if self.data_set == 'value':
2861 diff_params = [tm, Da, Dr, alpha, beta, gamma]
2862
2863
2864 elif self.data_set == 'error':
2865 self.relax.data.diff[self.run].tm_err = tm
2866 self.relax.data.diff[self.run].Da_err = Da
2867 self.relax.data.diff[self.run].Dr_err = Dr
2868 self.relax.data.diff[self.run].alpha_err = alpha
2869 self.relax.data.diff[self.run].beta_err = beta
2870 self.relax.data.diff[self.run].gamma_err = gamma
2871
2872
2873 else:
2874
2875 if not hasattr(self.relax.data.diff[self.run], 'tm_sim'):
2876 self.relax.data.diff[self.run].tm_sim = []
2877 if not hasattr(self.relax.data.diff[self.run], 'Da_sim'):
2878 self.relax.data.diff[self.run].Da_sim = []
2879 if not hasattr(self.relax.data.diff[self.run], 'Dr_sim'):
2880 self.relax.data.diff[self.run].Dr_sim = []
2881 if not hasattr(self.relax.data.diff[self.run], 'alpha_sim'):
2882 self.relax.data.diff[self.run].alpha_sim = []
2883 if not hasattr(self.relax.data.diff[self.run], 'beta_sim'):
2884 self.relax.data.diff[self.run].beta_sim = []
2885 if not hasattr(self.relax.data.diff[self.run], 'gamma_sim'):
2886 self.relax.data.diff[self.run].gamma_sim = []
2887
2888
2889 self.relax.data.diff[self.run].tm_sim.append(tm)
2890 self.relax.data.diff[self.run].Da_sim.append(Da)
2891 self.relax.data.diff[self.run].Dr_sim.append(Dr)
2892 self.relax.data.diff[self.run].alpha_sim.append(alpha)
2893 self.relax.data.diff[self.run].beta_sim.append(beta)
2894 self.relax.data.diff[self.run].gamma_sim.append(gamma)
2895
2896
2897
2898 if self.data_set == 'value' and diff_type:
2899
2900 spheroid_type = None
2901 if diff_type == 'oblate' or diff_type == 'prolate':
2902 spheroid_type = diff_type
2903
2904
2905 self.relax.generic.diffusion_tensor.init(run=self.run, params=diff_params, angle_units='rad', spheroid_type=spheroid_type)
2906
2907
2909 """Function for generating the sequence and or returning the residue index."""
2910
2911
2912 try:
2913 self.res_num = int(self.file_line[self.col['num']])
2914 except ValueError:
2915 raise RelaxError, "The residue number " + self.file_line[self.col['num']] + " is not an integer."
2916 self.res_name = self.file_line[self.col['name']]
2917
2918
2919 res_index = None
2920 for j in xrange(len(self.relax.data.res[self.run])):
2921 if self.relax.data.res[self.run][j].num == self.res_num and self.relax.data.res[self.run][j].name == self.res_name:
2922 res_index = j
2923 break
2924 if res_index == None:
2925 raise RelaxError, "Residue " + `self.res_num` + " " + self.res_name + " cannot be found in the sequence."
2926
2927
2928 return res_index
2929
2930
2932 """Function for reading the model-free data."""
2933
2934
2935 data = self.relax.data.res[self.run][self.res_index]
2936
2937
2938 if self.data_set == 'value':
2939
2940 model = self.file_line[self.col['model']]
2941
2942
2943 equation = self.file_line[self.col['eqi']]
2944
2945
2946 params = eval(self.file_line[self.col['params']])
2947
2948
2949 if params:
2950 for i in xrange(len(params)):
2951 if params[i] == 'tm':
2952 params[i] = 'local_tm'
2953
2954
2955 if model and equation:
2956 self.model_setup(self.run, model=model, equation=equation, params=params, res_num=self.res_num)
2957
2958
2959 if self.data_set == 'value':
2960
2961 try:
2962 data.s2 = float(self.file_line[self.col['s2']]) * self.return_conversion_factor('s2')
2963 except ValueError:
2964 data.s2 = None
2965
2966
2967 try:
2968 data.s2f = float(self.file_line[self.col['s2f']]) * self.return_conversion_factor('s2f')
2969 except ValueError:
2970 data.s2f = None
2971
2972
2973 try:
2974 data.s2s = float(self.file_line[self.col['s2s']]) * self.return_conversion_factor('s2s')
2975 except ValueError:
2976 data.s2s = None
2977
2978
2979 try:
2980 data.local_tm = float(self.file_line[self.col['local_tm']]) * self.return_conversion_factor('local_tm')
2981 except ValueError:
2982 data.local_tm = None
2983
2984
2985 try:
2986 data.te = float(self.file_line[self.col['te']]) * self.return_conversion_factor('te')
2987 except ValueError:
2988 data.te = None
2989
2990
2991 try:
2992 data.tf = float(self.file_line[self.col['tf']]) * self.return_conversion_factor('tf')
2993 except ValueError:
2994 data.tf = None
2995
2996
2997 try:
2998 data.ts = float(self.file_line[self.col['ts']]) * self.return_conversion_factor('ts')
2999 except ValueError:
3000 data.ts = None
3001
3002
3003 try:
3004 data.rex = float(self.file_line[self.col['rex']]) * self.return_conversion_factor('rex')
3005 except ValueError:
3006 data.rex = None
3007
3008
3009 try:
3010 data.r = float(self.file_line[self.col['r']]) * self.return_conversion_factor('r')
3011 except ValueError:
3012 data.r = None
3013
3014
3015 try:
3016 data.csa = float(self.file_line[self.col['csa']]) * self.return_conversion_factor('csa')
3017 except ValueError:
3018 data.csa = None
3019
3020
3021 if self.param_set == 'diff' or self.param_set == 'all':
3022 self.relax.data.chi2[self.run] = eval(self.file_line[self.col['chi2']])
3023 self.relax.data.iter[self.run] = eval(self.file_line[self.col['iter']])
3024 self.relax.data.f_count[self.run] = eval(self.file_line[self.col['f_count']])
3025 self.relax.data.g_count[self.run] = eval(self.file_line[self.col['g_count']])
3026 self.relax.data.h_count[self.run] = eval(self.file_line[self.col['h_count']])
3027 if self.file_line[self.col['warn']] == 'None':
3028 self.relax.data.warning[self.run] = None
3029 else:
3030 self.relax.data.warning[self.run] = replace(self.file_line[self.col['warn']], '_', ' ')
3031
3032
3033 else:
3034 data.chi2 = eval(self.file_line[self.col['chi2']])
3035 data.iter = eval(self.file_line[self.col['iter']])
3036 data.f_count = eval(self.file_line[self.col['f_count']])
3037 data.g_count = eval(self.file_line[self.col['g_count']])
3038 data.h_count = eval(self.file_line[self.col['h_count']])
3039 if self.file_line[self.col['warn']] == 'None':
3040 data.warning = None
3041 else:
3042 data.warning = replace(self.file_line[self.col['warn']], '_', ' ')
3043
3044
3045 if self.data_set == 'error':
3046
3047 try:
3048 data.s2_err = float(self.file_line[self.col['s2']]) * self.return_conversion_factor('s2')
3049 except ValueError:
3050 data.s2_err = None
3051
3052
3053 try:
3054 data.s2f_err = float(self.file_line[self.col['s2f']]) * self.return_conversion_factor('s2f')
3055 except ValueError:
3056 data.s2f_err = None
3057
3058
3059 try:
3060 data.s2s_err = float(self.file_line[self.col['s2s']]) * self.return_conversion_factor('s2s')
3061 except ValueError:
3062 data.s2s_err = None
3063
3064
3065 try:
3066 data.local_tm_err = float(self.file_line[self.col['local_tm']]) * self.return_conversion_factor('local_tm')
3067 except ValueError:
3068 data.local_tm_err = None
3069
3070
3071 try:
3072 data.te_err = float(self.file_line[self.col['te']]) * self.return_conversion_factor('te')
3073 except ValueError:
3074 data.te_err = None
3075
3076
3077 try:
3078 data.tf_err = float(self.file_line[self.col['tf']]) * self.return_conversion_factor('tf')
3079 except ValueError:
3080 data.tf_err = None
3081
3082
3083 try:
3084 data.ts_err = float(self.file_line[self.col['ts']]) * self.return_conversion_factor('ts')
3085 except ValueError:
3086 data.ts_err = None
3087
3088
3089 try:
3090 data.rex_err = float(self.file_line[self.col['rex']]) * self.return_conversion_factor('rex')
3091 except ValueError:
3092 data.rex_err = None
3093
3094
3095 try:
3096 data.r_err = float(self.file_line[self.col['r']]) * self.return_conversion_factor('r')
3097 except ValueError:
3098 data.r_err = None
3099
3100
3101 try:
3102 data.csa_err = float(self.file_line[self.col['csa']]) * self.return_conversion_factor('csa')
3103 except ValueError:
3104 data.csa_err = None
3105
3106
3107
3108 if self.data_set == 'sim_0':
3109
3110 param_names = self.data_names(set='params')
3111
3112
3113 min_names = self.data_names(set='min')
3114
3115
3116 for object_name in param_names:
3117
3118 sim_object_name = object_name + '_sim'
3119
3120
3121 setattr(data, sim_object_name, [])
3122
3123
3124 for object_name in min_names:
3125
3126 sim_object_name = object_name + '_sim'
3127
3128
3129 if self.param_set == 'diff' or self.param_set == 'all':
3130 setattr(self.relax.data, sim_object_name, {})
3131 object = getattr(self.relax.data, sim_object_name)
3132 object[self.run] = []
3133 else:
3134 setattr(data, sim_object_name, [])
3135
3136
3137 if self.data_set != 'value' and self.data_set != 'error':
3138
3139 try:
3140 data.s2_sim.append(float(self.file_line[self.col['s2']]) * self.return_conversion_factor('s2'))
3141 except ValueError:
3142 data.s2_sim.append(None)
3143
3144
3145 try:
3146 data.s2f_sim.append(float(self.file_line[self.col['s2f']]) * self.return_conversion_factor('s2f'))
3147 except ValueError:
3148 data.s2f_sim.append(None)
3149
3150
3151 try:
3152 data.s2s_sim.append(float(self.file_line[self.col['s2s']]) * self.return_conversion_factor('s2s'))
3153 except ValueError:
3154 data.s2s_sim.append(None)
3155
3156
3157 try:
3158 data.local_tm_sim.append(float(self.file_line[self.col['local_tm']]) * self.return_conversion_factor('local_tm'))
3159 except ValueError:
3160 data.local_tm_sim.append(None)
3161
3162
3163 try:
3164 data.te_sim.append(float(self.file_line[self.col['te']]) * self.return_conversion_factor('te'))
3165 except ValueError:
3166 data.te_sim.append(None)
3167
3168
3169 try:
3170 data.tf_sim.append(float(self.file_line[self.col['tf']]) * self.return_conversion_factor('tf'))
3171 except ValueError:
3172 data.tf_sim.append(None)
3173
3174
3175 try:
3176 data.ts_sim.append(float(self.file_line[self.col['ts']]) * self.return_conversion_factor('ts'))
3177 except ValueError:
3178 data.ts_sim.append(None)
3179
3180
3181 try:
3182 data.rex_sim.append(float(self.file_line[self.col['rex']]) * self.return_conversion_factor('rex'))
3183 except ValueError:
3184 data.rex_sim.append(None)
3185
3186
3187 try:
3188 data.r_sim.append(float(self.file_line[self.col['r']]) * self.return_conversion_factor('r'))
3189 except ValueError:
3190 data.r_sim.append(None)
3191
3192
3193 try:
3194 data.csa_sim.append(float(self.file_line[self.col['csa']]) * self.return_conversion_factor('csa'))
3195 except ValueError:
3196 data.csa_sim.append(None)
3197
3198
3199 if self.param_set == 'diff' or self.param_set == 'all':
3200 self.relax.data.chi2_sim[self.run].append(eval(self.file_line[self.col['chi2']]))
3201 self.relax.data.iter_sim[self.run].append(eval(self.file_line[self.col['iter']]))
3202 self.relax.data.f_count_sim[self.run].append(eval(self.file_line[self.col['f_count']]))
3203 self.relax.data.g_count_sim[self.run].append(eval(self.file_line[self.col['g_count']]))
3204 self.relax.data.h_count_sim[self.run].append(eval(self.file_line[self.col['h_count']]))
3205 if self.file_line[self.col['warn']] == 'None':
3206 self.relax.data.warning_sim[self.run].append(None)
3207 else:
3208 self.relax.data.warning_sim[self.run].append(replace(self.file_line[self.col['warn']], '_', ' '))
3209
3210
3211 else:
3212 data.chi2_sim.append(eval(self.file_line[self.col['chi2']]))
3213 data.iter_sim.append(eval(self.file_line[self.col['iter']]))
3214 data.f_count_sim.append(eval(self.file_line[self.col['f_count']]))
3215 data.g_count_sim.append(eval(self.file_line[self.col['g_count']]))
3216 data.h_count_sim.append(eval(self.file_line[self.col['h_count']]))
3217 if self.file_line[self.col['warn']] == 'None':
3218 data.warning_sim.append(None)
3219 else:
3220 data.warning_sim.append(replace(self.file_line[self.col['warn']], '_', ' '))
3221
3222
3224 """Function for reading the parameter set."""
3225
3226
3227 if self.file_line[self.col['param_set']] != 'None':
3228 self.param_set = self.file_line[self.col['param_set']]
3229 else:
3230 return
3231
3232
3233 if self.param_set == 'local_tm' or self.param_set == 'mf':
3234 diff_fixed = 1
3235 res_fixed = 0
3236
3237
3238 elif self.param_set == 'diff':
3239 diff_fixed = 0
3240 res_fixed = 1
3241
3242
3243 elif self.param_set == 'all':
3244 diff_fixed = 0
3245 res_fixed = 0
3246
3247
3248 elif self.param_set == 'None':
3249 self.param_set = None
3250 diff_fixed = None
3251 res_fixed = None
3252
3253
3254 if self.param_set != 'local_tm' and diff_fixed != None:
3255 self.relax.data.diff[self.run].fixed = diff_fixed
3256
3257
3258 for i in xrange(len(self.relax.data.res[self.run])):
3259 if res_fixed != None:
3260 self.relax.data.res[self.run][i].fixed = res_fixed
3261
3262
3264 """Function for reading the PDB file."""
3265
3266
3267 pdb = self.file_line[self.col['pdb']]
3268
3269
3270 pdb_model = eval(self.file_line[self.col['pdb_model']])
3271
3272
3273 if self.col.has_key('pdb_heteronuc'):
3274 pdb_heteronuc = self.file_line[self.col['pdb_heteronuc']]
3275
3276
3277 if self.col.has_key('pdb_proton'):
3278 pdb_proton = self.file_line[self.col['pdb_proton']]
3279
3280
3281 if not pdb == 'None':
3282 self.relax.generic.pdb.load(run=self.run, file=pdb, model=pdb_model, heteronuc=pdb_heteronuc, proton=pdb_proton, calc_vectors=0, fail=0, print_flag=print_flag)
3283 return 1
3284 else:
3285 return 0
3286
3287
3289 """Function for reading the relaxation data."""
3290
3291
3292 if self.data_set == 'error':
3293 return
3294
3295
3296 self.ri_labels = eval(self.file_line[self.col['ri_labels']])
3297 self.remap_table = eval(self.file_line[self.col['remap_table']])
3298 self.frq_labels = eval(self.file_line[self.col['frq_labels']])
3299 self.frq = eval(self.file_line[self.col['frq']])
3300
3301
3302 if not self.ri_labels:
3303 return
3304
3305
3306 values = []
3307 errors = []
3308
3309
3310 for i in xrange(len(self.ri_labels)):
3311
3312 data_col = self.col['frq'] + i + 1
3313 error_col = self.col['frq'] + len(self.ri_labels) + i + 1
3314
3315
3316 values.append(eval(self.file_line[data_col]))
3317 errors.append(eval(self.file_line[error_col]))
3318
3319
3320 sim = 0
3321 if self.data_set != 'value' and self.data_set != 'error':
3322 sim = 1
3323
3324
3325 self.relax.specific.relax_data.add_residue(run=self.run, res_index=self.res_index, ri_labels=self.ri_labels, remap_table=self.remap_table, frq_labels=self.frq_labels, frq=self.frq, values=values, errors=errors, sim=sim)
3326
3327
3329 """Function for reading the results file."""
3330
3331
3332 self.run = run
3333
3334
3335 header = file_data[0]
3336 file_data = file_data[1:]
3337
3338
3339 self.read_columnar_col_numbers(header)
3340
3341
3342 if len(self.col) < 2:
3343 raise RelaxInvalidDataError
3344
3345
3346 nucleus_set = 0
3347 sim_num = None
3348 sims = []
3349 all_select_sim = []
3350 diff_data_set = 0
3351 diff_error_set = 0
3352 diff_sim_set = None
3353 self.param_set = None
3354 pdb = 0
3355 pdb_model = None
3356 pdb_heteronuc = None
3357 pdb_proton = None
3358 self.ri_labels = None
3359
3360
3361 for self.file_line in file_data:
3362
3363 self.data_set = self.file_line[self.col['data_set']]
3364
3365
3366 if self.data_set != 'value':
3367 break
3368
3369
3370 self.read_columnar_sequence()
3371
3372
3373
3374 for self.file_line in file_data:
3375
3376 self.data_set = self.file_line[self.col['data_set']]
3377
3378
3379 self.res_index = self.read_columnar_find_index()
3380
3381
3382 data = self.relax.data.res[self.run][self.res_index]
3383
3384
3385 if len(self.file_line) == 4:
3386 continue
3387
3388
3389 if not nucleus_set:
3390 if self.file_line[self.col['nucleus']] != 'None':
3391 self.relax.generic.nuclei.set_values(self.file_line[self.col['nucleus']])
3392 nucleus_set = 1
3393
3394
3395 if self.data_set != 'value' and self.data_set != 'error':
3396
3397 sim_num = split(self.data_set, '_')
3398 try:
3399 sim_num = int(sim_num[1])
3400 except:
3401 raise RelaxError, "The simulation number '%s' is invalid." % sim_num
3402
3403
3404 if sim_num not in sims:
3405
3406 sims.append(sim_num)
3407 all_select_sim.append([])
3408
3409
3410 all_select_sim[-1].append(int(self.file_line[self.col['select']]))
3411
3412
3413 if self.data_set == 'value' and not diff_data_set:
3414 self.read_columnar_diff_tensor()
3415 diff_data_set = 1
3416
3417
3418 elif self.data_set == 'error' and not diff_error_set:
3419 self.read_columnar_diff_tensor()
3420 diff_error_set = 1
3421
3422
3423 elif self.data_set != 'value' and self.data_set != 'error' and sim_num != diff_sim_set:
3424 self.read_columnar_diff_tensor()
3425 diff_sim_set = sim_num
3426
3427
3428 if self.param_set == None:
3429 self.read_columnar_param_set()
3430
3431
3432 if not pdb:
3433 if self.read_columnar_pdb(print_flag):
3434 pdb = 1
3435
3436
3437 if self.data_set == 'value':
3438 self.read_columnar_xh_vect()
3439
3440
3441 self.read_columnar_relax_data()
3442
3443
3444 self.read_columnar_model_free_data()
3445
3446
3447 if len(sims):
3448
3449 all_select_sim = transpose(array(all_select_sim))
3450
3451
3452 self.relax.generic.monte_carlo.setup(self.run, number=len(sims), all_select_sim=all_select_sim)
3453
3454
3455 self.relax.data.sim_state[self.run] = 0
3456
3457
3459 """Function for generating the sequence."""
3460
3461
3462 try:
3463 res_num = int(self.file_line[self.col['num']])
3464 except ValueError:
3465 raise RelaxError, "The residue number " + self.file_line[self.col['num']] + " is not an integer."
3466 res_name = self.file_line[self.col['name']]
3467
3468
3469 self.relax.generic.sequence.add(self.run, res_num, res_name, select=int(self.file_line[self.col['select']]))
3470
3471
3473 """Function for reading the XH unit vectors."""
3474
3475
3476 xh_vect = eval(self.file_line[self.col['xh_vect']])
3477 if xh_vect:
3478
3479 try:
3480 xh_vect = array(xh_vect, Float64)
3481 except:
3482 raise RelaxError, "The XH unit vector " + self.file_line[self.col['xh_vect']] + " is invalid."
3483
3484
3485 self.relax.generic.pdb.set_vector(run=self.run, res=self.res_index, xh_vect=xh_vect)
3486
3487
3488 self.relax.data.res[self.run][self.res_index].heteronuc = self.file_line[self.col['pdb_heteronuc']]
3489 self.relax.data.res[self.run][self.res_index].proton = self.file_line[self.col['pdb_proton']]
3490
3491
3493 """Function for removing the local tm parameter from the model-free parameters."""
3494
3495
3496 self.run = run
3497
3498
3499 if not self.run in self.relax.data.run_names:
3500 raise RelaxNoRunError, self.run
3501
3502
3503 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)]
3504 if function_type != 'mf':
3505 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type)
3506
3507
3508 if not self.relax.data.res.has_key(self.run):
3509 raise RelaxNoSequenceError, self.run
3510
3511
3512 for i in xrange(len(self.relax.data.res[self.run])):
3513
3514 data = self.relax.data.res[self.run][i]
3515
3516
3517 if not data.select:
3518 continue
3519
3520
3521 if res_num != None and res_num != data.num:
3522 continue
3523
3524
3525 if not hasattr(data, 'params') or not 'local_tm' in data.params:
3526 continue
3527
3528
3529 data.params.remove('local_tm')
3530
3531
3532 if match('^tm', data.model):
3533 data.model = data.model[1:]
3534
3535
3536 data.local_tm = None
3537
3538
3539 data.chi2 = None
3540 data.iter = None
3541 data.f_count = None
3542 data.g_count = None
3543 data.h_count = None
3544 data.warning = None
3545
3546
3547 self.relax.data.chi2[self.run] = None
3548 self.relax.data.iter[self.run] = None
3549 self.relax.data.f_count[self.run] = None
3550 self.relax.data.g_count[self.run] = None
3551 self.relax.data.h_count[self.run] = None
3552 self.relax.data.warning[self.run] = None
3553
3554
3556 """Function for returning the factor of conversion between different parameter units.
3557
3558 For example, the internal representation of te is in seconds, whereas the external
3559 representation is in picoseconds, therefore this function will return 1e-12 for te.
3560 """
3561
3562
3563 object_name = self.return_data_name(param)
3564
3565
3566 if object_name == 'tm' or object_name == 'local_tm':
3567 return 1e-9
3568
3569
3570 elif object_name in ['te', 'tf', 'ts']:
3571 return 1e-12
3572
3573
3574 elif object_name == 'rex':
3575 return 1.0 / (2.0 * pi * self.relax.data.frq[self.run][0])**2
3576
3577
3578 elif object_name == 'r':
3579 return 1e-10
3580
3581
3582 elif object_name == 'csa':
3583 return 1e-6
3584
3585
3586 else:
3587 return 1.0
3588
3589
3591 """
3592 Model-free data type string matching patterns
3593 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3594
3595 ____________________________________________________________________________________________
3596 | | | |
3597 | Data type | Object name | Patterns |
3598 |________________________|______________|__________________________________________________|
3599 | | | |
3600 | Local tm | 'local_tm' | '[Ll]ocal[ -_]tm' |
3601 | | | |
3602 | Order parameter S2 | 's2' | '^[Ss]2$' |
3603 | | | |
3604 | Order parameter S2f | 's2f' | '^[Ss]2f$' |
3605 | | | |
3606 | Order parameter S2s | 's2s' | '^[Ss]2s$' |
3607 | | | |
3608 | Correlation time te | 'te' | '^te$' |
3609 | | | |
3610 | Correlation time tf | 'tf' | '^tf$' |
3611 | | | |
3612 | Correlation time ts | 'ts' | '^ts$' |
3613 | | | |
3614 | Chemical exchange | 'rex' | '^[Rr]ex$' or '[Cc]emical[ -_][Ee]xchange' |
3615 | | | |
3616 | Bond length | 'r' | '^r$' or '[Bb]ond[ -_][Ll]ength' |
3617 | | | |
3618 | CSA | 'csa' | '^[Cc][Ss][Aa]$' |
3619 |________________________|______________|__________________________________________________|
3620
3621 """
3622
3623
3624 if search('[Ll]ocal[ -_]tm', name):
3625 return 'local_tm'
3626
3627
3628 if search('^[Ss]2$', name):
3629 return 's2'
3630
3631
3632 if search('^[Ss]2f$', name):
3633 return 's2f'
3634
3635
3636 if search('^[Ss]2s$', name):
3637 return 's2s'
3638
3639
3640 if search('^te$', name):
3641 return 'te'
3642
3643
3644 if search('^tf$', name):
3645 return 'tf'
3646
3647
3648 if search('^ts$', name):
3649 return 'ts'
3650
3651
3652 if search('^[Rr]ex$', name) or search('[Cc]emical[ -_][Ee]xchange', name):
3653 return 'rex'
3654
3655
3656 if search('^r$', name) or search('[Bb]ond[ -_][Ll]ength', name):
3657 return 'r'
3658
3659
3660 if search('^[Cc][Ss][Aa]$', name):
3661 return 'csa'
3662
3663
3665 """Function for returning the Grace string representing the parameter for axis labelling."""
3666
3667
3668 object_name = self.return_data_name(param)
3669
3670
3671 if object_name == 'tm' or object_name == 'local_tm':
3672 return '\\xt\\f{}\\sm'
3673
3674
3675 elif object_name == 's2':
3676 return '\\qS\\v{0.4}\\z{0.71}2\\Q'
3677
3678
3679 elif object_name == 's2f':
3680 return '\\qS\\sf\\N\\h{-0.2}\\v{0.4}\\z{0.71}2\\Q'
3681
3682
3683 elif object_name == 's2s':
3684 return '\\qS\\ss\\N\\h{-0.2}\\v{0.4}\\z{0.71}2\\Q'
3685
3686
3687 elif object_name == 'te':
3688 return '\\xt\\f{}\\se'
3689
3690
3691 elif object_name == 'tf':
3692 return '\\xt\\f{}\\sf'
3693
3694
3695 elif object_name == 'ts':
3696 return '\\xt\\f{}\\ss'
3697
3698
3699 elif object_name == 'rex':
3700 return '\\qR\\sex\\Q'
3701
3702
3703 elif object_name == 'r':
3704 return 'Bond length'
3705
3706
3707 elif object_name == 'csa':
3708 return '\\qCSA\\Q'
3709
3710
3712 """Function for returning a string representing the parameters units.
3713
3714 For example, the internal representation of te is in seconds, whereas the external
3715 representation is in picoseconds, therefore this function will return the string
3716 'picoseconds' for te.
3717 """
3718
3719
3720 object_name = self.return_data_name(param)
3721
3722
3723 if object_name == 'tm' or object_name == 'local_tm':
3724 return 'ns'
3725
3726
3727 elif object_name in ['te', 'tf', 'ts']:
3728 return 'ps'
3729
3730
3731 elif object_name == 'rex':
3732 return self.relax.data.frq_labels[self.run][0] + ' MHz'
3733
3734
3735 elif object_name == 'r':
3736 return 'Angstrom'
3737
3738
3739 elif object_name == 'csa':
3740 return 'ppm'
3741
3742
3743 - def select_model(self, run=None, model=None, res_num=None):
3744 """Function for the selection of a preset model-free model."""
3745
3746
3747 self.run = run
3748
3749
3750 if not self.run in self.relax.data.run_names:
3751 raise RelaxNoRunError, self.run
3752
3753
3754 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)]
3755 if function_type != 'mf':
3756 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type)
3757
3758
3759 if not self.relax.data.res.has_key(self.run):
3760 raise RelaxNoSequenceError, self.run
3761
3762
3763
3764
3765
3766
3767 if model == 'm0':
3768 equation = 'mf_orig'
3769 params = []
3770 elif model == 'm1':
3771 equation = 'mf_orig'
3772 params = ['S2']
3773 elif model == 'm2':
3774 equation = 'mf_orig'
3775 params = ['S2', 'te']
3776 elif model == 'm3':
3777 equation = 'mf_orig'
3778 params = ['S2', 'Rex']
3779 elif model == 'm4':
3780 equation = 'mf_orig'
3781 params = ['S2', 'te', 'Rex']
3782 elif model == 'm5':
3783 equation = 'mf_ext'
3784 params = ['S2f', 'S2', 'ts']
3785 elif model == 'm6':
3786 equation = 'mf_ext'
3787 params = ['S2f', 'tf', 'S2', 'ts']
3788 elif model == 'm7':
3789 equation = 'mf_ext'
3790 params = ['S2f', 'S2', 'ts', 'Rex']
3791 elif model == 'm8':
3792 equation = 'mf_ext'
3793 params = ['S2f', 'tf', 'S2', 'ts', 'Rex']
3794 elif model == 'm9':
3795 equation = 'mf_orig'
3796 params = ['Rex']
3797
3798
3799 elif model == 'm10':
3800 equation = 'mf_orig'
3801 params = ['CSA']
3802 elif model == 'm11':
3803 equation = 'mf_orig'
3804 params = ['CSA', 'S2']
3805 elif model == 'm12':
3806 equation = 'mf_orig'
3807 params = ['CSA', 'S2', 'te']
3808 elif model == 'm13':
3809 equation = 'mf_orig'
3810 params = ['CSA', 'S2', 'Rex']
3811 elif model == 'm14':
3812 equation = 'mf_orig'
3813 params = ['CSA', 'S2', 'te', 'Rex']
3814 elif model == 'm15':
3815 equation = 'mf_ext'
3816 params = ['CSA', 'S2f', 'S2', 'ts']
3817 elif model == 'm16':
3818 equation = 'mf_ext'
3819 params = ['CSA', 'S2f', 'tf', 'S2', 'ts']
3820 elif model == 'm17':
3821 equation = 'mf_ext'
3822 params = ['CSA', 'S2f', 'S2', 'ts', 'Rex']
3823 elif model == 'm18':
3824 equation = 'mf_ext'
3825 params = ['CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex']
3826 elif model == 'm19':
3827 equation = 'mf_orig'
3828 params = ['CSA', 'Rex']
3829
3830
3831 elif model == 'm20':
3832 equation = 'mf_orig'
3833 params = ['r']
3834 elif model == 'm21':
3835 equation = 'mf_orig'
3836 params = ['r', 'S2']
3837 elif model == 'm22':
3838 equation = 'mf_orig'
3839 params = ['r', 'S2', 'te']
3840 elif model == 'm23':
3841 equation = 'mf_orig'
3842 params = ['r', 'S2', 'Rex']
3843 elif model == 'm24':
3844 equation = 'mf_orig'
3845 params = ['r', 'S2', 'te', 'Rex']
3846 elif model == 'm25':
3847 equation = 'mf_ext'
3848 params = ['r', 'S2f', 'S2', 'ts']
3849 elif model == 'm26':
3850 equation = 'mf_ext'
3851 params = ['r', 'S2f', 'tf', 'S2', 'ts']
3852 elif model == 'm27':
3853 equation = 'mf_ext'
3854 params = ['r', 'S2f', 'S2', 'ts', 'Rex']
3855 elif model == 'm28':
3856 equation = 'mf_ext'
3857 params = ['r', 'S2f', 'tf', 'S2', 'ts', 'Rex']
3858 elif model == 'm29':
3859 equation = 'mf_orig'
3860 params = ['r', 'Rex']
3861
3862
3863 elif model == 'm30':
3864 equation = 'mf_orig'
3865 params = ['r', 'CSA']
3866 elif model == 'm31':
3867 equation = 'mf_orig'
3868 params = ['r', 'CSA', 'S2']
3869 elif model == 'm32':
3870 equation = 'mf_orig'
3871 params = ['r', 'CSA', 'S2', 'te']
3872 elif model == 'm33':
3873 equation = 'mf_orig'
3874 params = ['r', 'CSA', 'S2', 'Rex']
3875 elif model == 'm34':
3876 equation = 'mf_orig'
3877 params = ['r', 'CSA', 'S2', 'te', 'Rex']
3878 elif model == 'm35':
3879 equation = 'mf_ext'
3880 params = ['r', 'CSA', 'S2f', 'S2', 'ts']
3881 elif model == 'm36':
3882 equation = 'mf_ext'
3883 params = ['r', 'CSA', 'S2f', 'tf', 'S2', 'ts']
3884 elif model == 'm37':
3885 equation = 'mf_ext'
3886 params = ['r', 'CSA', 'S2f', 'S2', 'ts', 'Rex']
3887 elif model == 'm38':
3888 equation = 'mf_ext'
3889 params = ['r', 'CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex']
3890 elif model == 'm39':
3891 equation = 'mf_orig'
3892 params = ['r', 'CSA', 'Rex']
3893
3894
3895
3896
3897
3898
3899 elif model == 'tm0':
3900 equation = 'mf_orig'
3901 params = ['local_tm']
3902 elif model == 'tm1':
3903 equation = 'mf_orig'
3904 params = ['local_tm', 'S2']
3905 elif model == 'tm2':
3906 equation = 'mf_orig'
3907 params = ['local_tm', 'S2', 'te']
3908 elif model == 'tm3':
3909 equation = 'mf_orig'
3910 params = ['local_tm', 'S2', 'Rex']
3911 elif model == 'tm4':
3912 equation = 'mf_orig'
3913 params = ['local_tm', 'S2', 'te', 'Rex']
3914 elif model == 'tm5':
3915 equation = 'mf_ext'
3916 params = ['local_tm', 'S2f', 'S2', 'ts']
3917 elif model == 'tm6':
3918 equation = 'mf_ext'
3919 params = ['local_tm', 'S2f', 'tf', 'S2', 'ts']
3920 elif model == 'tm7':
3921 equation = 'mf_ext'
3922 params = ['local_tm', 'S2f', 'S2', 'ts', 'Rex']
3923 elif model == 'tm8':
3924 equation = 'mf_ext'
3925 params = ['local_tm', 'S2f', 'tf', 'S2', 'ts', 'Rex']
3926 elif model == 'tm9':
3927 equation = 'mf_orig'
3928 params = ['local_tm', 'Rex']
3929
3930
3931 elif model == 'tm10':
3932 equation = 'mf_orig'
3933 params = ['local_tm', 'CSA']
3934 elif model == 'tm11':
3935 equation = 'mf_orig'
3936 params = ['local_tm', 'CSA', 'S2']
3937 elif model == 'tm12':
3938 equation = 'mf_orig'
3939 params = ['local_tm', 'CSA', 'S2', 'te']
3940 elif model == 'tm13':
3941 equation = 'mf_orig'
3942 params = ['local_tm', 'CSA', 'S2', 'Rex']
3943 elif model == 'tm14':
3944 equation = 'mf_orig'
3945 params = ['local_tm', 'CSA', 'S2', 'te', 'Rex']
3946 elif model == 'tm15':
3947 equation = 'mf_ext'
3948 params = ['local_tm', 'CSA', 'S2f', 'S2', 'ts']
3949 elif model == 'tm16':
3950 equation = 'mf_ext'
3951 params = ['local_tm', 'CSA', 'S2f', 'tf', 'S2', 'ts']
3952 elif model == 'tm17':
3953 equation = 'mf_ext'
3954 params = ['local_tm', 'CSA', 'S2f', 'S2', 'ts', 'Rex']
3955 elif model == 'tm18':
3956 equation = 'mf_ext'
3957 params = ['local_tm', 'CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex']
3958 elif model == 'tm19':
3959 equation = 'mf_orig'
3960 params = ['local_tm', 'CSA', 'Rex']
3961
3962
3963 elif model == 'tm20':
3964 equation = 'mf_orig'
3965 params = ['local_tm', 'r']
3966 elif model == 'tm21':
3967 equation = 'mf_orig'
3968 params = ['local_tm', 'r', 'S2']
3969 elif model == 'tm22':
3970 equation = 'mf_orig'
3971 params = ['local_tm', 'r', 'S2', 'te']
3972 elif model == 'tm23':
3973 equation = 'mf_orig'
3974 params = ['local_tm', 'r', 'S2', 'Rex']
3975 elif model == 'tm24':
3976 equation = 'mf_orig'
3977 params = ['local_tm', 'r', 'S2', 'te', 'Rex']
3978 elif model == 'tm25':
3979 equation = 'mf_ext'
3980 params = ['local_tm', 'r', 'S2f', 'S2', 'ts']
3981 elif model == 'tm26':
3982 equation = 'mf_ext'
3983 params = ['local_tm', 'r', 'S2f', 'tf', 'S2', 'ts']
3984 elif model == 'tm27':
3985 equation = 'mf_ext'
3986 params = ['local_tm', 'r', 'S2f', 'S2', 'ts', 'Rex']
3987 elif model == 'tm28':
3988 equation = 'mf_ext'
3989 params = ['local_tm', 'r', 'S2f', 'tf', 'S2', 'ts', 'Rex']
3990 elif model == 'tm29':
3991 equation = 'mf_orig'
3992 params = ['local_tm', 'r', 'Rex']
3993
3994
3995 elif model == 'tm30':
3996 equation = 'mf_orig'
3997 params = ['local_tm', 'r', 'CSA']
3998 elif model == 'tm31':
3999 equation = 'mf_orig'
4000 params = ['local_tm', 'r', 'CSA', 'S2']
4001 elif model == 'tm32':
4002 equation = 'mf_orig'
4003 params = ['local_tm', 'r', 'CSA', 'S2', 'te']
4004 elif model == 'tm33':
4005 equation = 'mf_orig'
4006 params = ['local_tm', 'r', 'CSA', 'S2', 'Rex']
4007 elif model == 'tm34':
4008 equation = 'mf_orig'
4009 params = ['local_tm', 'r', 'CSA', 'S2', 'te', 'Rex']
4010 elif model == 'tm35':
4011 equation = 'mf_ext'
4012 params = ['local_tm', 'r', 'CSA', 'S2f', 'S2', 'ts']
4013 elif model == 'tm36':
4014 equation = 'mf_ext'
4015 params = ['local_tm', 'r', 'CSA', 'S2f', 'tf', 'S2', 'ts']
4016 elif model == 'tm37':
4017 equation = 'mf_ext'
4018 params = ['local_tm', 'r', 'CSA', 'S2f', 'S2', 'ts', 'Rex']
4019 elif model == 'tm38':
4020 equation = 'mf_ext'
4021 params = ['local_tm', 'r', 'CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex']
4022 elif model == 'tm39':
4023 equation = 'mf_orig'
4024 params = ['local_tm', 'r', 'CSA', 'Rex']
4025
4026
4027 else:
4028 raise RelaxError, "The model '" + model + "' is invalid."
4029
4030
4031 self.model_setup(self.run, model, equation, params, res_num)
4032
4033
4035 """
4036 Model-free set details
4037 ~~~~~~~~~~~~~~~~~~~~~~
4038
4039 Setting a parameter value may have no effect depending on which model-free model is chosen,
4040 for example if S2f values and S2s values are set but the run corresponds to model-free model
4041 'm4' then, because these data values are not parameters of the model, they will have no
4042 effect.
4043
4044 Note that the Rex values are scaled quadratically with field strength and should be supplied
4045 as a field strength independent value. Use the following formula to get the correct value:
4046
4047 value = Rex / (2.0 * pi * frequency) ** 2
4048
4049 where:
4050 Rex is the chemical exchange value for the current frequency.
4051 pi is in the namespace of relax, ie just type 'pi'.
4052 frequency is the proton frequency corresponding to the data.
4053 """
4054
4055
4056 - def set_error(self, run, instance, index, error):
4057 """Function for setting parameter errors."""
4058
4059
4060 self.run = run
4061
4062
4063 inc = 0
4064
4065
4066 param_names = self.data_names(set='params')
4067
4068
4069
4070
4071
4072 if self.param_set == 'diff' or self.param_set == 'all':
4073
4074 if self.relax.data.diff[self.run].type == 'sphere':
4075
4076 if index == 0:
4077 self.relax.data.diff[self.run].tm_err = error
4078
4079
4080 inc = inc + 1
4081
4082
4083 elif self.relax.data.diff[self.run].type == 'spheroid':
4084
4085 if index == 0:
4086 self.relax.data.diff[self.run].tm_err = error
4087 elif index == 1:
4088 self.relax.data.diff[self.run].Da_err = error
4089 elif index == 2:
4090 self.relax.data.diff[self.run].theta_err = error
4091 elif index == 3:
4092 self.relax.data.diff[self.run].phi_err = error
4093
4094
4095 inc = inc + 4
4096
4097
4098 elif self.relax.data.diff[self.run].type == 'ellipsoid':
4099
4100 if index == 0:
4101 self.relax.data.diff[self.run].tm_err = error
4102 elif index == 1:
4103 self.relax.data.diff[self.run].Da_err = error
4104 elif index == 2:
4105 self.relax.data.diff[self.run].Dr_err = error
4106 elif index == 3:
4107 self.relax.data.diff[self.run].alpha_err = error
4108 elif index == 4:
4109 self.relax.data.diff[self.run].beta_err = error
4110 elif index == 5:
4111 self.relax.data.diff[self.run].gamma_err = error
4112
4113
4114 inc = inc + 6
4115
4116
4117
4118
4119
4120 if self.param_set == 'all':
4121
4122 for i in xrange(len(self.relax.data.res[self.run])):
4123
4124 if not self.relax.data.res[self.run][i].select:
4125 continue
4126
4127
4128 for param in param_names:
4129
4130 if index == inc:
4131 setattr(self.relax.data.res[self.run][i], param + "_err", error)
4132
4133
4134 inc = inc + 1
4135
4136
4137
4138
4139
4140 if self.param_set == 'mf' or self.param_set == 'local_tm':
4141
4142 if not self.relax.data.res[self.run][instance].select:
4143 return
4144
4145
4146 for param in param_names:
4147
4148 if index == inc:
4149 setattr(self.relax.data.res[self.run][instance], param + "_err", error)
4150
4151
4152 inc = inc + 1
4153
4154
4156 """Function for returning the array of selected simulation flags."""
4157
4158
4159 self.run = run
4160
4161
4162 self.param_set = self.determine_param_set_type()
4163
4164
4165 if self.param_set == 'all' or self.param_set == 'diff':
4166 if not hasattr(self.relax.data, 'select_sim'):
4167 self.relax.data.select_sim = {}
4168 self.relax.data.select_sim[self.run] = select_sim
4169
4170
4171 else:
4172 self.relax.data.res[self.run][instance].select_sim = select_sim
4173
4174
4176 """Function to update the other model-free parameters."""
4177
4178
4179 data = self.relax.data.res[self.run][index]
4180
4181
4182 if param == 'S2f':
4183
4184 if hasattr(data, 's2s') and data.s2s != None:
4185 data.s2 = data.s2f * data.s2s
4186
4187
4188
4189 if param == 'S2s':
4190
4191 if hasattr(data, 's2f') and data.s2f != None:
4192 data.s2 = data.s2f * data.s2s
4193
4194
4196 """Function for initialising Monte Carlo parameter values."""
4197
4198
4199 self.run = run
4200
4201
4202 self.param_set = self.determine_param_set_type()
4203
4204
4205 param_names = self.data_names(set='params')
4206
4207
4208 min_names = self.data_names(set='min')
4209
4210
4211 if self.param_set == 'diff' or self.param_set == 'all':
4212
4213 if self.relax.data.diff[self.run].type == 'sphere':
4214 diff_params = ['tm']
4215
4216
4217 elif self.relax.data.diff[self.run].type == 'spheroid':
4218 diff_params = ['tm', 'Da', 'theta', 'phi']
4219
4220
4221 elif self.relax.data.diff[self.run].type == 'ellipsoid':
4222 diff_params = ['tm', 'Da', 'Dr', 'alpha', 'beta', 'gamma']
4223
4224
4225
4226
4227
4228
4229 if self.param_set == 'diff' or self.param_set == 'all':
4230
4231 for object_name in diff_params:
4232
4233 sim_object_name = object_name + '_sim'
4234
4235
4236 if hasattr(self.relax.data.diff[self.run], sim_object_name):
4237 raise RelaxError, "Monte Carlo parameter values have already been set."
4238
4239
4240 for object_name in min_names:
4241
4242 sim_object_name = object_name + '_sim'
4243
4244
4245 if hasattr(self.relax.data, sim_object_name):
4246 raise RelaxError, "Monte Carlo parameter values have already been set."
4247
4248
4249 if self.param_set != 'diff':
4250 for i in xrange(len(self.relax.data.res[self.run])):
4251
4252 if not self.relax.data.res[self.run][i].select:
4253 continue
4254
4255
4256 for object_name in param_names:
4257
4258 sim_object_name = object_name + '_sim'
4259
4260
4261 if hasattr(self.relax.data.res[self.run][i], sim_object_name):
4262 raise RelaxError, "Monte Carlo parameter values have already been set."
4263
4264
4265
4266
4267
4268
4269 for object_name in min_names:
4270
4271 sim_object_name = object_name + '_sim'
4272
4273
4274 setattr(self.relax.data, sim_object_name, {})
4275
4276
4277 sim_object = getattr(self.relax.data, sim_object_name)
4278
4279
4280 sim_object[self.run] = []
4281
4282
4283 for j in xrange(self.relax.data.sim_number[self.run]):
4284
4285 object = getattr(self.relax.data, object_name)
4286
4287
4288 if not object.has_key(self.run):
4289 continue
4290
4291
4292 sim_object[self.run].append(deepcopy(object[self.run]))
4293
4294
4295 if self.param_set == 'diff' or self.param_set == 'all':
4296
4297 for object_name in diff_params:
4298
4299 sim_object_name = object_name + '_sim'
4300
4301
4302 setattr(self.relax.data.diff[self.run], sim_object_name, [])
4303
4304
4305 sim_object = getattr(self.relax.data.diff[self.run], sim_object_name)
4306
4307
4308 for j in xrange(self.relax.data.sim_number[self.run]):
4309
4310 sim_object.append(deepcopy(getattr(self.relax.data.diff[self.run], object_name)))
4311
4312
4313 if self.param_set != 'diff':
4314 for i in xrange(len(self.relax.data.res[self.run])):
4315
4316 if not self.relax.data.res[self.run][i].select:
4317 continue
4318
4319
4320 for object_name in param_names:
4321
4322 sim_object_name = object_name + '_sim'
4323
4324
4325 setattr(self.relax.data.res[self.run][i], sim_object_name, [])
4326
4327
4328 sim_object = getattr(self.relax.data.res[self.run][i], sim_object_name)
4329
4330
4331 for j in xrange(self.relax.data.sim_number[self.run]):
4332
4333 sim_object.append(deepcopy(getattr(self.relax.data.res[self.run][i], object_name)))
4334
4335
4336 for object_name in min_names:
4337
4338 sim_object_name = object_name + '_sim'
4339
4340
4341 setattr(self.relax.data.res[self.run][i], sim_object_name, [])
4342
4343
4344 sim_object = getattr(self.relax.data.res[self.run][i], sim_object_name)
4345
4346
4347 for j in xrange(self.relax.data.sim_number[self.run]):
4348
4349 sim_object.append(deepcopy(getattr(self.relax.data.res[self.run][i], object_name)))
4350
4351
4353 """Function for packing Monte Carlo simulation data."""
4354
4355
4356 if hasattr(self.relax.data.res[run][i], 'relax_sim_data'):
4357 raise RelaxError, "Monte Carlo simulation data already exists."
4358
4359
4360 self.relax.data.res[run][i].relax_sim_data = sim_data
4361
4362
4364 """Function for returning the array of simulation chi-squared values."""
4365
4366
4367 self.run = run
4368
4369
4370 self.param_set = self.determine_param_set_type()
4371
4372
4373 if self.param_set == 'all' or self.param_set == 'diff':
4374 return self.relax.data.chi2_sim[self.run]
4375
4376
4377 else:
4378 return self.relax.data.res[self.run][instance].chi2_sim
4379
4380
4382 """Function for returning the array of simulation parameter values."""
4383
4384
4385 self.run = run
4386
4387
4388 inc = 0
4389
4390
4391 param_names = self.data_names(set='params')
4392
4393
4394
4395
4396
4397 if self.param_set == 'diff' or self.param_set == 'all':
4398
4399 if self.relax.data.diff[self.run].type == 'sphere':
4400
4401 if index == 0:
4402 return self.relax.data.diff[self.run].tm_sim
4403
4404
4405 inc = inc + 1
4406
4407
4408 elif self.relax.data.diff[self.run].type == 'spheroid':
4409
4410 if index == 0:
4411 return self.relax.data.diff[self.run].tm_sim
4412 elif index == 1:
4413 return self.relax.data.diff[self.run].Da_sim
4414 elif index == 2:
4415 return self.relax.data.diff[self.run].theta_sim
4416 elif index == 3:
4417 return self.relax.data.diff[self.run].phi_sim
4418
4419
4420 inc = inc + 4
4421
4422
4423 elif self.relax.data.diff[self.run].type == 'ellipsoid':
4424
4425 if index == 0:
4426 return self.relax.data.diff[self.run].tm_sim
4427 elif index == 1:
4428 return self.relax.data.diff[self.run].Da_sim
4429 elif index == 2:
4430 return self.relax.data.diff[self.run].Dr_sim
4431 elif index == 3:
4432 return self.relax.data.diff[self.run].alpha_sim
4433 elif index == 4:
4434 return self.relax.data.diff[self.run].beta_sim
4435 elif index == 5:
4436 return self.relax.data.diff[self.run].gamma_sim
4437
4438
4439 inc = inc + 6
4440
4441
4442
4443
4444
4445 if self.param_set == 'all':
4446
4447 for i in xrange(len(self.relax.data.res[self.run])):
4448
4449 if not self.relax.data.res[self.run][i].select:
4450 continue
4451
4452
4453 for param in param_names:
4454
4455 if index == inc:
4456 return getattr(self.relax.data.res[self.run][i], param + "_sim")
4457
4458
4459 inc = inc + 1
4460
4461
4462
4463
4464
4465 if self.param_set == 'mf' or self.param_set == 'local_tm':
4466
4467 if not self.relax.data.res[self.run][instance].select:
4468 return
4469
4470
4471 for param in param_names:
4472
4473 if index == inc:
4474 return getattr(self.relax.data.res[self.run][instance], param + "_sim")
4475
4476
4477 inc = inc + 1
4478
4479
4481 """Function for returning the array of selected simulation flags."""
4482
4483
4484 self.run = run
4485
4486
4487 self.param_set = self.determine_param_set_type()
4488
4489
4490 if self.param_set == 'all' or self.param_set == 'diff':
4491 return self.relax.data.select_sim[self.run]
4492
4493
4494 else:
4495 return self.relax.data.res[self.run][instance].select_sim
4496
4497
4498 - def skip_function(self, run=None, instance=None, min_instances=None, num_instances=None):
4499 """Function for skiping certain data."""
4500
4501
4502 self.run = run
4503
4504
4505 self.param_set = self.determine_param_set_type()
4506
4507
4508 combine = 0
4509 if min_instances == 1 and min_instances != num_instances:
4510 combine = 1
4511
4512
4513 if (self.param_set == 'mf' or self.param_set == 'local_tm') and not combine and not self.relax.data.res[self.run][instance].select:
4514 return 1
4515
4516
4517 return 0
4518
4519
4520 - def unselect(self, run, i, sim_index=None):
4521 """Function for unselecting models or simulations."""
4522
4523
4524 self.run = run
4525
4526
4527 self.param_set = self.determine_param_set_type()
4528
4529
4530 if sim_index != None:
4531
4532 if self.param_set == 'mf' or self.param_set == 'local_tm':
4533 self.relax.data.res[self.run][i].select_sim[sim_index] = 0
4534
4535
4536 else:
4537 self.relax.data.select_sim[self.run][sim_index] = 0
4538
4539
4540 else:
4541
4542 if self.param_set == 'mf' or self.param_set == 'local_tm':
4543 self.relax.data.res[self.run][i].select = 0
4544
4545
4546 - def write_columnar_line(self, file=None, num=None, name=None, select=None, select_sim=None, data_set=None, nucleus=None, model=None, equation=None, params=None, param_set=None, s2=None, s2f=None, s2s=None, local_tm=None, te=None, tf=None, ts=None, rex=None, r=None, csa=None, chi2=None, i=None, f=None, g=None, h=None, warn=None, diff_type=None, diff_params=None, pdb=None, pdb_model=None, pdb_heteronuc=None, pdb_proton=None, xh_vect=None, ri_labels=None, remap_table=None, frq_labels=None, frq=None, ri=None, ri_error=None):
4547 """Function for printing a single line of the columnar formatted results."""
4548
4549
4550 file.write("%-4s %-5s " % (num, name))
4551
4552
4553 if select_sim != None:
4554 file.write("%-9s " % select_sim)
4555 else:
4556 file.write("%-9s " % select)
4557
4558
4559 file.write("%-9s " % data_set)
4560
4561
4562 file.write("%-7s " % nucleus)
4563
4564
4565 file.write("%-5s %-9s %-35s " % (model, equation, params))
4566
4567
4568 file.write("%-10s " % param_set)
4569
4570
4571 file.write("%-25s " % s2)
4572 file.write("%-25s " % s2f)
4573 file.write("%-25s " % s2s)
4574 file.write("%-25s " % local_tm)
4575 file.write("%-25s " % te)
4576 file.write("%-25s " % tf)
4577 file.write("%-25s " % ts)
4578 file.write("%-25s " % rex)
4579 file.write("%-25s " % r)
4580 file.write("%-25s " % csa)
4581
4582
4583 file.write("%-25s %-8s %-8s %-8s %-8s %-45s " % (chi2, i, f, g, h, warn))
4584
4585
4586 file.write("%-10s " % diff_type)
4587 if diff_params:
4588 for i in xrange(len(diff_params)):
4589 file.write("%-25s " % diff_params[i])
4590
4591
4592 file.write("%-40s " % pdb)
4593 file.write("%-10s " % pdb_model)
4594 file.write("%-15s " % pdb_heteronuc)
4595 file.write("%-15s " % pdb_proton)
4596
4597
4598 file.write("%-70s " % xh_vect)
4599
4600
4601 if ri_labels:
4602 file.write("%-40s " % ri_labels)
4603 file.write("%-25s " % remap_table)
4604 file.write("%-25s " % frq_labels)
4605 file.write("%-30s " % frq)
4606
4607
4608 if ri:
4609 for i in xrange(len(ri)):
4610 if ri[i] == None:
4611 file.write("%-25s " % 'None')
4612 else:
4613 file.write("%-25s " % ri[i])
4614
4615
4616 if ri_error:
4617 for i in xrange(len(ri_error)):
4618 if ri_error[i] == None:
4619 file.write("%-25s " % 'None')
4620 else:
4621 file.write("%-25s " % ri_error[i])
4622
4623
4624 file.write("\n")
4625
4626
4628 """Function for printing the results into a file."""
4629
4630
4631 self.run = run
4632
4633
4634 self.param_set = self.determine_param_set_type()
4635
4636
4637
4638
4639
4640
4641 diff_params = None
4642 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run):
4643
4644 if self.relax.data.diff[self.run].type == 'sphere':
4645 diff_params = ['tm_(s)']
4646
4647
4648 elif self.relax.data.diff[self.run].type == 'spheroid':
4649 diff_params = ['tm_(s)', 'Da_(1/s)', 'theta_(deg)', 'phi_(deg)']
4650
4651
4652 elif self.relax.data.diff[self.run].type == 'ellipsoid':
4653 diff_params = ['tm_(s)', 'Da_(1/s)', 'Dr_(1/s)', 'alpha_(deg)', 'beta_(deg)', 'gamma_(deg)']
4654
4655
4656 ri = []
4657 ri_error = []
4658 if hasattr(self.relax.data, 'num_ri'):
4659 for i in xrange(self.relax.data.num_ri[self.run]):
4660 ri.append('Ri_(' + self.relax.data.ri_labels[self.run][i] + "_" + self.relax.data.frq_labels[self.run][self.relax.data.remap_table[self.run][i]] + ")")
4661 ri_error.append('Ri_error_(' + self.relax.data.ri_labels[self.run][i] + "_" + self.relax.data.frq_labels[self.run][self.relax.data.remap_table[self.run][i]] + ")")
4662
4663
4664 self.write_columnar_line(file=file, num='Num', name='Name', select='Selected', data_set='Data_set', nucleus='Nucleus', model='Model', equation='Equation', params='Params', param_set='Param_set', s2='S2', s2f='S2f', s2s='S2s', local_tm='Local_tm_(' + self.return_units('local_tm') + ')', te='te_(' + self.return_units('te') + ')', tf='tf_(' + self.return_units('tf') + ')', ts='ts_(' + self.return_units('ts') + ')', rex='Rex_(' + replace(self.return_units('rex'), ' ', '_') + ')', r='Bond_length_(' + self.return_units('r') + ')', csa='CSA_(' + self.return_units('csa') + ')', chi2='Chi-squared', i='Iter', f='f_count', g='g_count', h='h_count', warn='Warning', diff_type='Diff_type', diff_params=diff_params, pdb='PDB', pdb_model='PDB_model', pdb_heteronuc='PDB_heteronuc', pdb_proton='PDB_proton', xh_vect='XH_vector', ri_labels='Ri_labels', remap_table='Remap_table', frq_labels='Frq_labels', frq='Frequencies', ri=ri, ri_error=ri_error)
4665
4666
4667
4668
4669
4670
4671 nucleus = self.relax.generic.nuclei.find_nucleus()
4672
4673
4674 diff_type = None
4675 diff_params = None
4676 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run):
4677
4678 if self.relax.data.diff[self.run].type == 'sphere':
4679 diff_type = 'sphere'
4680 diff_params = [`self.relax.data.diff[self.run].tm`]
4681
4682
4683 elif self.relax.data.diff[self.run].type == 'spheroid':
4684 diff_type = self.relax.data.diff[self.run].spheroid_type
4685 if diff_type == None:
4686 diff_type = 'spheroid'
4687 diff_params = [`self.relax.data.diff[self.run].tm`, `self.relax.data.diff[self.run].Da`, `self.relax.data.diff[self.run].theta * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].phi * 360 / (2.0 * pi)`]
4688
4689
4690 elif self.relax.data.diff[self.run].type == 'ellipsoid':
4691 diff_type = 'ellipsoid'
4692 diff_params = [`self.relax.data.diff[self.run].tm`, `self.relax.data.diff[self.run].Da`, `self.relax.data.diff[self.run].Dr`, `self.relax.data.diff[self.run].alpha * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].beta * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].gamma * 360 / (2.0 * pi)`]
4693
4694
4695 pdb = None
4696 pdb_model = None
4697 pdb_heteronuc = None
4698 pdb_proton = None
4699 if self.relax.data.pdb.has_key(self.run):
4700 pdb = self.relax.data.pdb[self.run].file_name
4701 pdb_model = self.relax.data.pdb[self.run].model
4702 pdb_heteronuc = self.relax.data.pdb[self.run].heteronuc
4703 pdb_proton = self.relax.data.pdb[self.run].proton
4704
4705
4706 try:
4707 ri_labels = replace(`self.relax.data.ri_labels[self.run]`, ' ', '')
4708 remap_table = replace(`self.relax.data.remap_table[self.run]`, ' ', '')
4709 frq_labels = replace(`self.relax.data.frq_labels[self.run]`, ' ', '')
4710 frq = replace(`self.relax.data.frq[self.run]`, ' ', '')
4711 except AttributeError:
4712 ri_labels = `None`
4713 remap_table = `None`
4714 frq_labels = `None`
4715 frq = `None`
4716
4717
4718 for i in xrange(len(self.relax.data.res[self.run])):
4719
4720 data = self.relax.data.res[self.run][i]
4721
4722
4723 model = None
4724 if hasattr(data, 'model'):
4725 model = data.model
4726
4727 equation = None
4728 if hasattr(data, 'equation'):
4729 equation = data.equation
4730
4731 params = None
4732 if hasattr(data, 'params'):
4733 params = replace(`data.params`, ' ', '')
4734
4735
4736 s2 = None
4737 if hasattr(data, 's2') and data.s2 != None:
4738 s2 = data.s2 / self.return_conversion_factor('s2')
4739 s2 = `s2`
4740
4741
4742 s2f = None
4743 if hasattr(data, 's2f') and data.s2f != None:
4744 s2f = data.s2f / self.return_conversion_factor('s2f')
4745 s2f = `s2f`
4746
4747
4748 s2s = None
4749 if hasattr(data, 's2s') and data.s2s != None:
4750 s2s = data.s2s / self.return_conversion_factor('s2s')
4751 s2s = `s2s`
4752
4753
4754 local_tm = None
4755 if hasattr(data, 'local_tm') and data.local_tm != None:
4756 local_tm = data.local_tm / self.return_conversion_factor('local_tm')
4757 local_tm = `local_tm`
4758
4759
4760 te = None
4761 if hasattr(data, 'te') and data.te != None:
4762 te = data.te / self.return_conversion_factor('te')
4763 te = `te`
4764
4765
4766 tf = None
4767 if hasattr(data, 'tf') and data.tf != None:
4768 tf = data.tf / self.return_conversion_factor('tf')
4769 tf = `tf`
4770
4771
4772 ts = None
4773 if hasattr(data, 'ts') and data.ts != None:
4774 ts = data.ts / self.return_conversion_factor('ts')
4775 ts = `ts`
4776
4777
4778 rex = None
4779 if hasattr(data, 'rex') and data.rex != None:
4780 rex = data.rex / self.return_conversion_factor('rex')
4781 rex = `rex`
4782
4783
4784 r = None
4785 if hasattr(data, 'r') and data.r != None:
4786 r = data.r / self.return_conversion_factor('r')
4787 r = `r`
4788
4789
4790 csa = None
4791 if hasattr(data, 'csa') and data.csa != None:
4792 csa = data.csa / self.return_conversion_factor('csa')
4793 csa = `csa`
4794
4795
4796 try:
4797
4798 if self.param_set == 'diff' or self.param_set == 'all':
4799 chi2 = `self.relax.data.chi2[self.run]`
4800 iter = self.relax.data.iter[self.run]
4801 f = self.relax.data.f_count[self.run]
4802 g = self.relax.data.g_count[self.run]
4803 h = self.relax.data.h_count[self.run]
4804 if type(self.relax.data.warning[self.run]) == str:
4805 warn = replace(self.relax.data.warning[self.run], ' ', '_')
4806 else:
4807 warn = self.relax.data.warning[self.run]
4808
4809
4810 else:
4811 chi2 = `data.chi2`
4812 iter = data.iter
4813 f = data.f_count
4814 g = data.g_count
4815 h = data.h_count
4816 if type(data.warning) == str:
4817 warn = replace(data.warning, ' ', '_')
4818 else:
4819 warn = data.warning
4820
4821
4822 except:
4823 chi2 = None
4824 iter = None
4825 f = None
4826 g = None
4827 h = None
4828 warn = None
4829
4830
4831 xh_vect = None
4832 if hasattr(data, 'xh_vect'):
4833 xh_vect = replace(`data.xh_vect.tolist()`, ' ', '')
4834
4835
4836 ri = []
4837 ri_error = []
4838 if hasattr(self.relax.data, 'num_ri'):
4839 for i in xrange(self.relax.data.num_ri[self.run]):
4840 try:
4841
4842 index = None
4843 for j in xrange(data.num_ri):
4844 if data.ri_labels[j] == self.relax.data.ri_labels[self.run][i] and data.frq_labels[data.remap_table[j]] == self.relax.data.frq_labels[self.run][self.relax.data.remap_table[self.run][i]]:
4845 index = j
4846
4847
4848 ri.append(`data.relax_data[index]`)
4849 ri_error.append(`data.relax_error[index]`)
4850
4851
4852 except:
4853 ri.append(None)
4854 ri_error.append(None)
4855
4856
4857 self.write_columnar_line(file=file, num=data.num, name=data.name, select=data.select, data_set='value', nucleus=nucleus, model=model, equation=equation, params=params, param_set=self.param_set, s2=s2, s2f=s2f, s2s=s2s, local_tm=local_tm, te=te, tf=tf, ts=ts, rex=rex, r=r, csa=csa, chi2=chi2, i=iter, f=f, g=g, h=h, warn=warn, diff_type=diff_type, diff_params=diff_params, pdb=pdb, pdb_model=pdb_model, pdb_heteronuc=pdb_heteronuc, pdb_proton=pdb_proton, xh_vect=xh_vect, ri_labels=ri_labels, remap_table=remap_table, frq_labels=frq_labels, frq=frq, ri=ri, ri_error=ri_error)
4858
4859
4860
4861
4862
4863
4864 if self.has_errors():
4865
4866 diff_params = None
4867 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run):
4868
4869 if self.relax.data.diff[self.run].type == 'sphere':
4870 diff_params = [None]
4871
4872
4873 elif self.relax.data.diff[self.run].type == 'spheroid':
4874 diff_params = [None, None, None, None]
4875
4876
4877 elif self.relax.data.diff[self.run].type == 'ellipsoid':
4878 diff_params = [None, None, None, None, None, None]
4879
4880
4881 if self.param_set == 'diff' or self.param_set == 'all':
4882
4883 if self.relax.data.diff[self.run].type == 'sphere' and hasattr(self.relax.data.diff[self.run], 'tm_err'):
4884 diff_params = [`self.relax.data.diff[self.run].tm_err`]
4885
4886
4887 elif self.relax.data.diff[self.run].type == 'spheroid' and hasattr(self.relax.data.diff[self.run], 'tm_err'):
4888 diff_params = [`self.relax.data.diff[self.run].tm_err`, `self.relax.data.diff[self.run].Da_err`, `self.relax.data.diff[self.run].theta_err * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].phi_err * 360 / (2.0 * pi)`]
4889
4890
4891 elif self.relax.data.diff[self.run].type == 'ellipsoid' and hasattr(self.relax.data.diff[self.run], 'tm_err'):
4892 diff_params = [`self.relax.data.diff[self.run].tm_err`, `self.relax.data.diff[self.run].Da_err`, `self.relax.data.diff[self.run].Dr_err`, `self.relax.data.diff[self.run].alpha_err * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].beta_err * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].gamma_err * 360 / (2.0 * pi)`]
4893
4894
4895 for i in xrange(len(self.relax.data.res[self.run])):
4896
4897 data = self.relax.data.res[self.run][i]
4898
4899
4900 model = None
4901 if hasattr(data, 'model'):
4902 model = data.model
4903
4904 equation = None
4905 if hasattr(data, 'equation'):
4906 equation = data.equation
4907
4908 params = None
4909 if hasattr(data, 'params'):
4910 params = replace(`data.params`, ' ', '')
4911
4912
4913 s2 = None
4914 if hasattr(data, 's2_err') and data.s2_err != None:
4915 s2 = data.s2_err / self.return_conversion_factor('s2')
4916 s2 = `s2`
4917
4918
4919 s2f = None
4920 if hasattr(data, 's2f_err') and data.s2f_err != None:
4921 s2f = data.s2f_err / self.return_conversion_factor('s2f')
4922 s2f = `s2f`
4923
4924
4925 s2s = None
4926 if hasattr(data, 's2s_err') and data.s2s_err != None:
4927 s2s = data.s2s_err / self.return_conversion_factor('s2s')
4928 s2s = `s2s`
4929
4930
4931 local_tm = None
4932 if hasattr(data, 'local_tm_err') and data.local_tm_err != None:
4933 local_tm = data.local_tm_err / self.return_conversion_factor('local_tm')
4934 local_tm = `local_tm`
4935
4936
4937 te = None
4938 if hasattr(data, 'te_err') and data.te_err != None:
4939 te = data.te_err / self.return_conversion_factor('te')
4940 te = `te`
4941
4942
4943 tf = None
4944 if hasattr(data, 'tf_err') and data.tf_err != None:
4945 tf = data.tf_err / self.return_conversion_factor('tf')
4946 tf = `tf`
4947
4948
4949 ts = None
4950 if hasattr(data, 'ts_err') and data.ts_err != None:
4951 ts = data.ts_err / self.return_conversion_factor('ts')
4952 ts = `ts`
4953
4954
4955 rex = None
4956 if hasattr(data, 'rex_err') and data.rex_err != None:
4957 rex = data.rex_err / self.return_conversion_factor('rex')
4958 rex = `rex`
4959
4960
4961 r = None
4962 if hasattr(data, 'r_err') and data.r_err != None:
4963 r = data.r_err / self.return_conversion_factor('r')
4964 r = `r`
4965
4966
4967 csa = None
4968 if hasattr(data, 'csa_err') and data.csa_err != None:
4969 csa = data.csa_err / self.return_conversion_factor('csa')
4970 csa = `csa`
4971
4972
4973 ri = []
4974 ri_error = []
4975 for i in xrange(self.relax.data.num_ri[self.run]):
4976 ri.append(None)
4977 ri_error.append(None)
4978
4979
4980 xh_vect = None
4981 if hasattr(data, 'xh_vect'):
4982 xh_vect = replace(`data.xh_vect.tolist()`, ' ', '')
4983
4984
4985 self.write_columnar_line(file=file, num=data.num, name=data.name, select=data.select, data_set='error', nucleus=nucleus, model=model, equation=equation, params=params, param_set=self.param_set, s2=s2, s2f=s2f, s2s=s2s, local_tm=local_tm, te=te, tf=tf, ts=ts, rex=rex, r=r, csa=csa, diff_type=diff_type, diff_params=diff_params, pdb=pdb, pdb_model=pdb_model, pdb_heteronuc=pdb_heteronuc, pdb_proton=pdb_proton, xh_vect=xh_vect, ri_labels=ri_labels, remap_table=remap_table, frq_labels=frq_labels, frq=frq, ri=ri, ri_error=ri_error)
4986
4987
4988
4989
4990
4991
4992 if hasattr(self.relax.data, 'sim_state') and self.relax.data.sim_state[self.run]:
4993
4994 for i in xrange(self.relax.data.sim_number[self.run]):
4995
4996 diff_params = None
4997 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run):
4998
4999 if self.param_set == 'diff' or self.param_set == 'all':
5000
5001 if self.relax.data.diff[self.run].type == 'sphere':
5002 diff_params = [`self.relax.data.diff[self.run].tm_sim[i]`]
5003
5004
5005 elif self.relax.data.diff[self.run].type == 'spheroid':
5006 diff_params = [`self.relax.data.diff[self.run].tm_sim[i]`, `self.relax.data.diff[self.run].Da_sim[i]`, `self.relax.data.diff[self.run].theta_sim[i] * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].phi_sim[i] * 360 / (2.0 * pi)`]
5007
5008
5009 elif self.relax.data.diff[self.run].type == 'ellipsoid':
5010 diff_params = [`self.relax.data.diff[self.run].tm_sim[i]`, `self.relax.data.diff[self.run].Da_sim[i]`, `self.relax.data.diff[self.run].Dr_sim[i]`, `self.relax.data.diff[self.run].alpha_sim[i] * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].beta_sim[i] * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].gamma_sim[i] * 360 / (2.0 * pi)`]
5011
5012
5013 else:
5014
5015 if self.relax.data.diff[self.run].type == 'sphere':
5016 diff_params = [None]
5017
5018
5019 elif self.relax.data.diff[self.run].type == 'spheroid':
5020 diff_params = [None, None, None, None]
5021
5022
5023 elif self.relax.data.diff[self.run].type == 'ellipsoid':
5024 diff_params = [None, None, None, None, None, None]
5025
5026
5027 for j in xrange(len(self.relax.data.res[self.run])):
5028
5029 data = self.relax.data.res[self.run][j]
5030
5031
5032 model = None
5033 if hasattr(data, 'model'):
5034 model = data.model
5035
5036 equation = None
5037 if hasattr(data, 'equation'):
5038 equation = data.equation
5039
5040 params = None
5041 if hasattr(data, 'params'):
5042 params = replace(`data.params`, ' ', '')
5043
5044
5045 if self.param_set == 'diff' or self.param_set == 'all':
5046 select_sim = self.relax.data.select_sim[self.run][i]
5047 else:
5048 select_sim = data.select_sim[i]
5049
5050
5051 s2 = None
5052 if hasattr(data, 's2_sim') and data.s2_sim[i] != None:
5053 s2 = data.s2_sim[i] / self.return_conversion_factor('s2')
5054 s2 = `s2`
5055
5056
5057 s2f = None
5058 if hasattr(data, 's2f_sim') and data.s2f_sim[i] != None:
5059 s2f = data.s2f_sim[i] / self.return_conversion_factor('s2f')
5060 s2f = `s2f`
5061
5062
5063 s2s = None
5064 if hasattr(data, 's2s_sim') and data.s2s_sim[i] != None:
5065 s2s = data.s2s_sim[i] / self.return_conversion_factor('s2s')
5066 s2s = `s2s`
5067
5068
5069 local_tm = None
5070 if hasattr(data, 'local_tm_sim') and data.local_tm_sim[i] != None:
5071 local_tm = data.local_tm_sim[i] / self.return_conversion_factor('local_tm')
5072 local_tm = `local_tm`
5073
5074
5075 te = None
5076 if hasattr(data, 'te_sim') and data.te_sim[i] != None:
5077 te = data.te_sim[i] / self.return_conversion_factor('te')
5078 te = `te`
5079
5080
5081 tf = None
5082 if hasattr(data, 'tf_sim') and data.tf_sim[i] != None:
5083 tf = data.tf_sim[i] / self.return_conversion_factor('tf')
5084 tf = `tf`
5085
5086
5087 ts = None
5088 if hasattr(data, 'ts_sim') and data.ts_sim[i] != None:
5089 ts = data.ts_sim[i] / self.return_conversion_factor('ts')
5090 ts = `ts`
5091
5092
5093 rex = None
5094 if hasattr(data, 'rex_sim') and data.rex_sim[i] != None:
5095 rex = data.rex_sim[i] / self.return_conversion_factor('rex')
5096 rex = `rex`
5097
5098
5099 r = None
5100 if hasattr(data, 'r_sim') and data.r_sim[i] != None:
5101 r = data.r_sim[i] / self.return_conversion_factor('r')
5102 r = `r`
5103
5104
5105 csa = None
5106 if hasattr(data, 'csa_sim') and data.csa_sim[i] != None:
5107 csa = data.csa_sim[i] / self.return_conversion_factor('csa')
5108 csa = `csa`
5109
5110
5111 try:
5112
5113 if self.param_set == 'diff' or self.param_set == 'all':
5114 chi2 = `self.relax.data.chi2_sim[self.run][i]`
5115 iter = self.relax.data.iter_sim[self.run][i]
5116 f = self.relax.data.f_count_sim[self.run][i]
5117 g = self.relax.data.g_count_sim[self.run][i]
5118 h = self.relax.data.h_count_sim[self.run][i]
5119 if type(self.relax.data.warning_sim[self.run][i]) == str:
5120 warn = replace(self.relax.data.warning_sim[self.run][i], ' ', '_')
5121 else:
5122 warn = self.relax.data.warning_sim[self.run][i]
5123
5124
5125 else:
5126 chi2 = `data.chi2_sim[i]`
5127 iter = data.iter_sim[i]
5128 f = data.f_count_sim[i]
5129 g = data.g_count_sim[i]
5130 h = data.h_count_sim[i]
5131 if type(data.warning_sim[i]) == str:
5132 warn = replace(data.warning_sim[i], ' ', '_')
5133 else:
5134 warn = data.warning_sim[i]
5135
5136
5137 except AttributeError:
5138 chi2 = None
5139 iter = None
5140 f = None
5141 g = None
5142 h = None
5143 warn = None
5144
5145
5146 ri = []
5147 ri_error = []
5148 if hasattr(self.relax.data, 'num_ri'):
5149 for k in xrange(self.relax.data.num_ri[self.run]):
5150 try:
5151
5152 index = None
5153 for l in xrange(data.num_ri):
5154 if data.ri_labels[l] == self.relax.data.ri_labels[self.run][k] and data.frq_labels[data.remap_table[l]] == self.relax.data.frq_labels[self.run][self.relax.data.remap_table[self.run][k]]:
5155 index = l
5156
5157
5158 ri.append(`data.relax_sim_data[i][index]`)
5159 ri_error.append(`data.relax_error[index]`)
5160
5161
5162 except:
5163 ri.append(None)
5164 ri_error.append(None)
5165
5166
5167 xh_vect = None
5168 if hasattr(data, 'xh_vect'):
5169 xh_vect = replace(`data.xh_vect.tolist()`, ' ', '')
5170
5171
5172 self.write_columnar_line(file=file, num=data.num, name=data.name, select=data.select, select_sim=select_sim, data_set='sim_'+`i`, nucleus=nucleus, model=model, equation=equation, params=params, param_set=self.param_set, s2=s2, s2f=s2f, s2s=s2s, local_tm=local_tm, te=te, tf=tf, ts=ts, rex=rex, r=r, csa=csa, chi2=chi2, i=iter, f=f, g=g, h=h, warn=warn, diff_type=diff_type, diff_params=diff_params, pdb=pdb, pdb_model=pdb_model, pdb_heteronuc=pdb_heteronuc, pdb_proton=pdb_proton, xh_vect=xh_vect, ri_labels=ri_labels, remap_table=remap_table, frq_labels=frq_labels, frq=frq, ri=ri, ri_error=ri_error)
5173
5174
5175
5176
5177
5178
5179
5180
5181
5182
5185 """Class containing the Molmol specific functions."""
5186
5187 self.relax = relax
5188
5189
5190 - def classic(self, data_type, colour_start, colour_end, colour_list):
5191 """
5192 Classic style
5193 ~~~~~~~~~~~~~
5194
5195 Creator: Edward d'Auvergne
5196
5197 Argument string: "classic"
5198
5199 Description: The classic style draws the backbone of the protein in the Molmol 'neon'
5200 style. Rather than colouring the amino acids to which the NH bond belongs, the three
5201 covalent bonds of the peptide bond from Ca to Ca in which the NH bond is located are
5202 coloured. Deselected residues are shown as black lines.
5203
5204 Supported data types:
5205 ____________________________________________________________________________________________
5206 | | | |
5207 | Data type | String | Description |
5208 |________________|_____________|___________________________________________________________|
5209 | | | |
5210 | S2. | 'S2' | The standard model-free order parameter, equal to S2f.S2s |
5211 | | | for the two timescale models. The default colour |
5212 | | | gradient starts at 'yellow' and ends at 'red'. |
5213 | | | |
5214 | S2f. | 'S2f' | The order parameter of the faster of two internal |
5215 | | | motions. Residues which are described by model-free |
5216 | | | models m1 to m4, the single timescale models, are |
5217 | | | illustrated as white neon bonds. The default colour |
5218 | | | gradient is the same as that for the S2 data type. |
5219 | | | |
5220 | S2s. | 'S2s' | The order parameter of the slower of two internal |
5221 | | | motions. This functions exactly as S2f except that S2s |
5222 | | | is plotted instead. |
5223 | | | |
5224 | Amplitude of | 'amp_fast' | Model independent display of the amplite of fast motions. |
5225 | fast motions. | | For residues described by model-free models m5 to m8, the |
5226 | | | value plotted is that of S2f. However, for residues |
5227 | | | described by models m1 to m4, what is shown is dependent |
5228 | | | on the timescale of the motions. This is because these |
5229 | | | single timescale models can, at times, be perfect |
5230 | | | approximations to the more complex two timescale models. |
5231 | | | Hence if te is less than 200 ps, S2 is plotted. Otherwise |
5232 | | | the peptide bond is coloured white. The default colour |
5233 | | | gradient is the same as that for S2. |
5234 | | | |
5235 | Amplitude of | 'amp_slow' | Model independent display of the amplite of slow motions, |
5236 | slow motions. | | arbitrarily defined as motions slower than 200 ps. For |
5237 | | | residues described by model-free models m5 to m8, the |
5238 | | | order parameter S2 is plotted if ts > 200 ps. For models |
5239 | | | m1 to m4, S2 is plotted if te > 200 ps. The default |
5240 | | | colour gradient is the same as that for S2. |
5241 | | | |
5242 | te. | 'te' | The correlation time, te. The default colour gradient |
5243 | | | starts at 'turquoise' and ends at 'blue'. |
5244 | | | |
5245 | tf. | 'tf' | The correlation time, tf. The default colour gradient is |
5246 | | | the same as that of te. |
5247 | | | |
5248 | ts. | 'ts' | The correlation time, ts. The default colour gradient |
5249 | | | starts at 'blue' and ends at 'black'. |
5250 | | | |
5251 | Timescale of | 'time_fast' | Model independent display of the timescale of fast |
5252 | fast motions | | motions. For models m5 to m8, only the parameter tf is |
5253 | | | plotted. For models m2 and m4, the parameter te is |
5254 | | | plotted only if it is less than 200 ps. All other |
5255 | | | residues are assumed to have a correlation time of zero. |
5256 | | | The default colour gradient is the same as that of te. |
5257 | | | |
5258 | Timescale of | 'time_slow' | Model independent display of the timescale of slow |
5259 | slow motions | | motions. For models m5 to m8, only the parameter ts is |
5260 | | | plotted. For models m2 and m4, the parameter te is |
5261 | | | plotted only if it is greater than 200 ps. All other |
5262 | | | residues are coloured white. The default colour gradient |
5263 | | | is the same as that of ts. |
5264 | | | |
5265 | Chemical | 'Rex' | The chemical exchange, Rex. Residues which experience no |
5266 | exchange | | chemical exchange are coloured white. The default colour |
5267 | | | gradient starts at 'yellow' and finishes at 'red'. |
5268 |________________|_____________|___________________________________________________________|
5269 """
5270
5271
5272
5273
5274 self.classic_header()
5275
5276
5277
5278
5279
5280 if data_type == 'S2':
5281
5282 for residue in self.relax.data.res[self.run]:
5283
5284 if not residue.select:
5285 continue
5286
5287
5288 if not hasattr(residue, 's2') or residue.s2 == None:
5289 continue
5290
5291
5292 self.classic_order_param(residue, residue.s2, colour_start, colour_end, colour_list)
5293
5294
5295
5296
5297
5298 elif data_type == 'S2f':
5299
5300 for residue in self.relax.data.res[self.run]:
5301
5302 if not residue.select:
5303 continue
5304
5305
5306 if not hasattr(residue, 's2f') or residue.s2f == None:
5307 self.classic_colour(res_num=residue.num, width=0.3, rgb_array=[1, 1, 1])
5308
5309
5310 else:
5311 self.classic_order_param(residue, residue.s2f, colour_start, colour_end, colour_list)
5312
5313
5314
5315
5316
5317 elif data_type == 'S2s':
5318
5319 for residue in self.relax.data.res[self.run]:
5320
5321 if not residue.select:
5322 continue
5323
5324
5325 if not hasattr(residue, 's2s') or residue.s2s == None:
5326 self.classic_colour(res_num=residue.num, width=0.3, rgb_array=[1, 1, 1])
5327
5328
5329 else:
5330 self.classic_order_param(residue, residue.s2s, colour_start, colour_end, colour_list)
5331
5332
5333
5334
5335
5336 elif data_type == 'amp_fast':
5337
5338 for residue in self.relax.data.res[self.run]:
5339
5340 if not residue.select:
5341 continue
5342
5343
5344 if search('tm[0-9]', residue.model):
5345 model = residue.model[1:]
5346 else:
5347 model = residue.model
5348
5349
5350 if hasattr(residue, 's2f') and residue.s2f != None:
5351 self.classic_order_param(residue, residue.s2f, colour_start, colour_end, colour_list)
5352
5353
5354 elif model == 'm1' or model == 'm3':
5355 self.classic_order_param(residue, residue.s2, colour_start, colour_end, colour_list)
5356
5357
5358 elif (model == 'm2' or model == 'm4') and residue.te <= 200e-12:
5359 self.classic_order_param(residue, residue.s2, colour_start, colour_end, colour_list)
5360
5361
5362 elif (model == 'm2' or model == 'm4') and residue.te > 200e-12:
5363 self.classic_colour(res_num=residue.num, width=0.3, rgb_array=[1, 1, 1])
5364
5365
5366 else:
5367 raise RelaxFault
5368
5369
5370
5371
5372
5373 elif data_type == 'amp_slow':
5374
5375 for residue in self.relax.data.res[self.run]:
5376
5377 if not residue.select:
5378 continue
5379
5380
5381 if search('tm[0-9]', residue.model):
5382 model = residue.model[1:]
5383 else:
5384 model = residue.model
5385
5386
5387 if hasattr(residue, 'ts') and residue.ts != None:
5388 self.classic_order_param(residue, residue.s2, colour_start, colour_end, colour_list)
5389
5390
5391 elif (model == 'm2' or model == 'm4') and residue.te > 200 * 1e-12:
5392 self.classic_order_param(residue, residue.s2, colour_start, colour_end, colour_list)
5393
5394
5395 else:
5396 self.classic_colour(res_num=residue.num, width=0.3, rgb_array=[1, 1, 1])
5397
5398
5399
5400
5401 elif data_type == 'te':
5402
5403 for residue in self.relax.data.res[self.run]:
5404
5405 if not residue.select:
5406 continue
5407
5408
5409 if not hasattr(residue, 'te') or residue.te == None:
5410 continue
5411
5412
5413 self.classic_correlation_time(residue, residue.te, colour_start, colour_end, colour_list)
5414
5415
5416
5417
5418
5419 elif data_type == 'tf':
5420
5421 for residue in self.relax.data.res[self.run]:
5422
5423 if not residue.select:
5424 continue
5425
5426
5427 if not hasattr(residue, 'tf') or residue.tf == None:
5428 continue
5429
5430
5431 self.classic_correlation_time(residue, residue.tf, colour_start, colour_end, colour_list)
5432
5433
5434
5435
5436
5437 elif data_type == 'ts':
5438
5439 for residue in self.relax.data.res[self.run]:
5440
5441 if not residue.select:
5442 continue
5443
5444
5445 if not hasattr(residue, 'ts') or residue.ts == None:
5446 continue
5447
5448
5449 if colour_start == None:
5450 colour_start = 'blue'
5451 if colour_end == None:
5452 colour_end = 'black'
5453
5454
5455 self.classic_correlation_time(residue, residue.ts / 10.0, colour_start, colour_end, colour_list)
5456
5457
5458
5459
5460
5461 elif data_type == 'time_fast':
5462
5463 for residue in self.relax.data.res[self.run]:
5464
5465 if not residue.select:
5466 continue
5467
5468
5469 if search('tm[0-9]', residue.model):
5470 model = residue.model[1:]
5471 else:
5472 model = residue.model
5473
5474
5475 if hasattr(residue, 'tf') and residue.tf != None:
5476 self.classic_correlation_time(residue, residue.tf, colour_start, colour_end, colour_list)
5477
5478
5479 elif (model == 'm2' or model == 'm4') and residue.te <= 200e-12:
5480 self.classic_correlation_time(residue, residue.te, colour_start, colour_end, colour_list)
5481
5482
5483
5484 else:
5485 self.classic_colour(res_num=residue.num, width=0.3, rgb_array=[1, 1, 1])
5486
5487
5488
5489
5490
5491 elif data_type == 'time_slow':
5492
5493 for residue in self.relax.data.res[self.run]:
5494
5495 if not residue.select:
5496 continue
5497
5498
5499 if search('tm[0-9]', residue.model):
5500 model = residue.model[1:]
5501 else:
5502 model = residue.model
5503
5504
5505 if colour_start == None:
5506 colour_start = 'blue'
5507 if colour_end == None:
5508 colour_end = 'black'
5509
5510
5511 if hasattr(residue, 'ts') and residue.ts != None:
5512 self.classic_correlation_time(residue, residue.ts / 10.0, colour_start, colour_end, colour_list)
5513
5514
5515 elif (model == 'm2' or model == 'm4') and residue.te > 200e-12:
5516 self.classic_correlation_time(residue, residue.te / 10.0, colour_start, colour_end, colour_list)
5517
5518
5519 else:
5520 self.classic_colour(res_num=residue.num, width=0.3, rgb_array=[1, 1, 1])
5521
5522
5523
5524
5525
5526 elif data_type == 'Rex':
5527
5528 for residue in self.relax.data.res[self.run]:
5529
5530 if not residue.select:
5531 continue
5532
5533
5534 if hasattr(residue, 'rex') and residue.rex != None:
5535 self.classic_rex(residue, residue.rex, colour_start, colour_end, colour_list)
5536
5537
5538 else:
5539 self.classic_colour(res_num=residue.num, width=0.3, rgb_array=[1, 1, 1])
5540
5541
5542
5543
5544
5545 else:
5546 raise RelaxUnknownDataTypeError, data_type
5547
5548
5550 """Colour the given peptide bond."""
5551
5552
5553 self.commands.append("SelectBond 'atom1.name = \"CA\" & atom2.name = \"C\" & res.num = " + `res_num-1` + "'")
5554 self.commands.append("StyleBond neon")
5555 self.commands.append("RadiusBond " + `width`)
5556 self.commands.append("ColorBond " + `rgb_array[0]` + " " + `rgb_array[1]` + " " + `rgb_array[2]`)
5557
5558
5559 self.commands.append("SelectBond 'atom1.name = \"C\" & atom2.name = \"N\" & res.num = " + `res_num-1` + "'")
5560 self.commands.append("StyleBond neon")
5561 self.commands.append("RadiusBond " + `width`)
5562 self.commands.append("ColorBond " + `rgb_array[0]` + " " + `rgb_array[1]` + " " + `rgb_array[2]`)
5563
5564
5565 self.commands.append("SelectBond 'atom1.name = \"N\" & atom2.name = \"CA\" & res.num = " + `res_num` + "'")
5566 self.commands.append("StyleBond neon")
5567 self.commands.append("RadiusBond " + `width`)
5568 self.commands.append("ColorBond " + `rgb_array[0]` + " " + `rgb_array[1]` + " " + `rgb_array[2]`)
5569
5570
5571 self.commands.append("")
5572
5573
5575 """Function for generating the bond width and colours for correlation times."""
5576
5577
5578 te = te * 1e12
5579
5580
5581 width = 2.0 - 200.0 / (te + 100.0)
5582
5583
5584 if width <= 0.0:
5585 width = 0.001
5586
5587
5588 colour_value = 1.0 / (te / 100.0 + 1.0)
5589
5590
5591 if colour_value < 0.0:
5592 colour_value = 0.0
5593 elif colour_value > 1.0:
5594 colour_value = 1.0
5595
5596
5597 if colour_start == None:
5598 colour_start = 'turquoise'
5599 if colour_end == None:
5600 colour_end = 'blue'
5601
5602
5603 rgb_array = self.relax.colour.linear_gradient(colour_value, colour_end, colour_start, colour_list)
5604
5605
5606 self.classic_colour(residue.num, width, rgb_array)
5607
5608
5610 """Create the header for the molmol macro."""
5611
5612
5613 self.commands.append("SelectBond ''")
5614 self.commands.append("StyleBond invisible")
5615
5616
5617 self.commands.append("SelectBond 'bb'")
5618 self.commands.append("StyleBond line")
5619
5620
5621 self.commands.append("ColorBond 0 0 0")
5622
5623
5625 """Function for generating the bond width and colours for order parameters."""
5626
5627
5628 if s2 <= 0.0:
5629 width = 2.0
5630 else:
5631 width = 2.0 * (1.0 - s2**2)
5632
5633
5634 if width <= 0.0:
5635 width = 0.001
5636
5637
5638 colour_value = s2 ** 4
5639
5640
5641 if colour_value < 0.0:
5642 colour_value = 0.0
5643 elif colour_value > 1.0:
5644 colour_value = 1.0
5645
5646
5647 if colour_start == None:
5648 colour_start = 'red'
5649 if colour_end == None:
5650 colour_end = 'yellow'
5651
5652
5653 rgb_array = self.relax.colour.linear_gradient(colour_value, colour_start, colour_end, colour_list)
5654
5655
5656 self.classic_colour(residue.num, width, rgb_array)
5657
5658
5659 - def classic_rex(self, residue, rex, colour_start, colour_end, colour_list):
5660 """Function for generating the bond width and colours for correlation times."""
5661
5662
5663 rex = rex * (2.0 * pi * self.relax.data.frq[self.run][0])**2
5664
5665
5666 width = 2.0 - 2.0 / (rex/5.0 + 1.0)
5667
5668
5669 if width <= 0.0:
5670 width = 0.001
5671
5672
5673 colour_value = 1.0 / (rex + 1.0)
5674
5675
5676 if colour_value < 0.0:
5677 colour_value = 0.0
5678 elif colour_value > 1.0:
5679 colour_value = 1.0
5680
5681
5682 if colour_start == None:
5683 colour_start = 'yellow'
5684 if colour_end == None:
5685 colour_end = 'red'
5686
5687
5688 rgb_array = self.relax.colour.linear_gradient(colour_value, colour_end, colour_start, colour_list)
5689
5690
5691 self.classic_colour(residue.num, width, rgb_array)
5692
5693
5694 - def macro(self, run, data_type, style, colour_start, colour_end, colour_list):
5695 """Create and return an array of Molmol macros of the model-free parameters."""
5696
5697
5698 self.run = run
5699
5700
5701 self.commands = []
5702
5703
5704 if style == 'classic':
5705 self.classic(data_type, colour_start, colour_end, colour_list)
5706
5707
5708 else:
5709 raise RelaxStyleError, style
5710
5711
5712 return self.commands
5713