specific_fns.consistency

32 - def __init__(self, relax):

33 """Class containing functions specific to consistency testing.""" 34 35 self.relax = relax

36 37

38 - def calculate(self, run=None, print_flag=1, sim_index=None):

39 """Calculation of the consistency functions.""" 40 41 # Run argument. 42 self.run = run 43 44 # Test if the frequency has been set. 45 if not hasattr(self.relax.data, 'ct_frq') or not self.relax.data.ct_frq.has_key(self.run) or type(self.relax.data.ct_frq[self.run]) != float: 46 raise RelaxError, "The frequency for the run " + `self.run` + " has not been set up." 47 48 # Test if the nucleus type has been set. 49 if not hasattr(self.relax.data, 'gx'): 50 raise RelaxNucleusError 51 52 # Test if the sequence data is loaded. 53 if not self.relax.data.res.has_key(self.run): 54 raise RelaxNoSequenceError, self.run 55 56 # Test if the CSA, bond length, angle Theta and correlation time values have been set. 57 for i in xrange(len(self.relax.data.res[self.run])): 58 # Skip unselected residues. 59 if not self.relax.data.res[self.run][i].select: 60 continue 61 62 # CSA value. 63 if not hasattr(self.relax.data.res[self.run][i], 'csa') or self.relax.data.res[self.run][i].csa == None: 64 raise RelaxNoValueError, "CSA" 65 66 # Bond length value. 67 if not hasattr(self.relax.data.res[self.run][i], 'r') or self.relax.data.res[self.run][i].r == None: 68 raise RelaxNoValueError, "bond length" 69 70 # Angle Theta 71 if not hasattr(self.relax.data.res[self.run][i], 'orientation') or self.relax.data.res[self.run][i].orientation == None: 72 raise RelaxNoValueError, "angle Theta" 73 74 # Correlation time 75 if not hasattr(self.relax.data.res[self.run][i], 'tc') or self.relax.data.res[self.run][i].tc == None: 76 raise RelaxNoValueError, "correlation time" 77 78 # Frequency index. 79 if self.relax.data.ct_frq[self.run] not in self.relax.data.frq[self.run]: 80 raise RelaxError, "No relaxation data corresponding to the frequency " + `self.relax.data.ct_frq[self.run]` + " has been loaded." 81 82 # Consistency testing. 83 for i in xrange(len(self.relax.data.res[self.run])): 84 # Reassign data structure. 85 data = self.relax.data.res[self.run][i] 86 87 # Skip unselected residues. 88 if not data.select: 89 continue 90 91 # Residue specific frequency index. 92 frq_index = None 93 for j in xrange(data.num_frq): 94 if data.frq[j] == self.relax.data.ct_frq[self.run]: 95 frq_index = j 96 if frq_index == None: 97 continue 98 99 # Set the R1, R2, and NOE to None. 100 r1 = None 101 r2 = None 102 noe = None 103 104 # Get the R1, R2, and NOE values corresponding to the set frequency. 105 for j in xrange(data.num_ri): 106 # R1. 107 if data.remap_table[j] == frq_index and data.ri_labels[j] == 'R1': 108 if sim_index == None: 109 r1 = data.relax_data[j] 110 else: 111 r1 = data.relax_sim_data[sim_index][j] 112 113 # R2. 114 if data.remap_table[j] == frq_index and data.ri_labels[j] == 'R2': 115 if sim_index == None: 116 r2 = data.relax_data[j] 117 else: 118 r2 = data.relax_sim_data[sim_index][j] 119 120 # NOE. 121 if data.remap_table[j] == frq_index and data.ri_labels[j] == 'NOE': 122 if sim_index == None: 123 noe = data.relax_data[j] 124 else: 125 noe = data.relax_sim_data[sim_index][j] 126 127 # Skip the residue if not all of the three value exist. 128 if r1 == None or r2 == None or noe == None: 129 continue 130 131 # Initialise the function to calculate. 132 self.ct = Consistency(frq=self.relax.data.ct_frq[self.run], gx=self.relax.data.gx, gh=self.relax.data.gh, mu0=self.relax.data.mu0, h_bar=self.relax.data.h_bar) 133 134 # Calculate the consistency functions. 135 j0, f_eta, f_r2 = self.ct.func(orientation=data.orientation, tc=data.tc, r=data.r, csa=data.csa, r1=r1, r2=r2, noe=noe) 136 137 # Consistency testing values. 138 if sim_index == None: 139 data.j0 = j0 140 data.f_eta = f_eta 141 data.f_r2 = f_r2 142 143 # Monte Carlo simulated consistency testing values. 144 else: 145 # Initialise the simulation data structures. 146 self.data_init(data, sim=1) 147 if data.j0_sim == None: 148 data.j0_sim = [] 149 data.f_eta_sim = [] 150 data.f_r2_sim = [] 151 152 # Consistency tests values. 153 data.j0_sim.append(j0) 154 data.f_eta_sim.append(f_eta) 155 data.f_r2_sim.append(f_r2)

156 157

158 - def data_init(self, data, sim=0):

159 """Function for initialising the data structures.""" 160 161 # Get the data names. 162 data_names = self.data_names() 163 164 # Loop over the data structure names. 165 for name in data_names: 166 # Simulation data structures. 167 if sim: 168 # Add '_sim' to the names. 169 name = name + '_sim' 170 171 # If the name is not in 'data', add it. 172 if not hasattr(data, name): 173 # Set the attribute. 174 setattr(data, name, None)

175 176

177 - def data_names(self):

178 """Function for returning a list of names of data structures. 179 180 Description 181 ~~~~~~~~~~~ 182 183 r: Bond length. 184 185 csa: CSA value. 186 187 orientation: Angle between the 15N-1H vector and the principal axis of the 15N chemical 188 shift tensor. 189 190 tc: Correlation time. 191 192 j0: Spectral density value at the zero frequency. 193 194 f_eta: Eta-test (from Fushman D. et al. (1998) JACS, 120: 10947-10952). 195 196 f_r2: R2-test (from Fushman D. et al. (1998) JACS, 120: 10947-10952). 197 """ 198 199 # Initialise. 200 names = [] 201 202 # Values. 203 names.append('r') 204 names.append('csa') 205 names.append('orientation') 206 names.append('tc') 207 208 # Consistency functions values. 209 names.append('j0') 210 names.append('f_eta') 211 names.append('f_r2') 212 213 return names

214 215

216 - def default_value(self, param):

217 """ 218 Consistency testing default values 219 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 220 221 _______________________________________________________________________________________ 222 | | | | 223 | Data type | Object name | Value | 224 |_______________________________________|_______________|_____________________________| 225 | | | | 226 | Bond length | 'r' | 1.02 * 1e-10 | 227 | | | | 228 | CSA | 'csa' | -172 * 1e-6 | 229 | | | | 230 | Angle Theta | 'orientation' | 15.7 | 231 | | | | 232 | Correlation time | 'tc' | 13 * 1e-9 | 233 |_______________________________________|_______________|_____________________________| 234 235 """ 236 237 # Bond length. 238 if param == 'r': 239 return 1.02 * 1e-10 240 241 # CSA. 242 if param == 'CSA': 243 return -172 * 1e-6 244 245 # Angle Theta 246 if param == 'orientation': 247 return 15.7 248 249 # Correlation time 250 if param == 'tc': 251 return 13 * 1e-9

252 253

254 - def num_instances(self, run=None):

255 """Function for returning the number of instances.""" 256 257 # Arguments. 258 self.run = run 259 260 # Test if sequence data is loaded. 261 if not self.relax.data.res.has_key(self.run): 262 return 0 263 264 # Return the number of residues. 265 return len(self.relax.data.res[self.run])

266 267

268 - def overfit_deselect(self, run):

269 """Function for deselecting residues without sufficient data to support calculation""" 270 271 # Test the sequence data exists: 272 if not self.relax.data.res.has_key(run): 273 raise RelaxNoSequenceError, run 274 275 # Loop over residue data: 276 for residue in self.relax.data.res[run]: 277 278 # Check for sufficient data 279 if not hasattr(residue, 'relax_data'): 280 residue.select = 0 281 continue 282 283 # Require 3 or more data points 284 if len(residue.relax_data) < 3: 285 residue.select = 0 286 continue

287 288

289 - def return_conversion_factor(self, stat_type):

290 """Dummy function for returning 1.0. This function is essential when writing grace files""" 291 292 return 1.0

293 294

295 - def return_data_name(self, name):

296 """ 297 Consistency testing data type string matching patterns 298 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 299 300 ____________________________________________________________________________________________ 301 | | | | 302 | Data type | Object name | Patterns | 303 |_______________________|_______________|__________________________________________________| 304 | | | | 305 | J(0) | 'j0' | '^[Jj]0$' or '[Jj]$0$' | 306 | | | | 307 | F_eta | 'f_eta' | '^[Ff]_[Ee][Tt][Aa]$' | 308 | | | | 309 | F_R2 | 'f_r2' | '^[Ff]_[Rr]2$' | 310 | | | | 311 | Bond length | 'r' | '^r$' or '[Bb]ond[ -_][Ll]ength' | 312 | | | | 313 | CSA | 'csa' | '^[Cc][Ss][Aa]$' | 314 | | | | 315 | Angle Theta | 'orientation' | '^[Oo][Rr][Ii][Ee][Nn][Tt][Aa][Tt][Ii][Oo][Nn]$' | 316 | | | | 317 | Correlation time | 'tc' | '^[Tt]c$' | 318 |_______________________|_______________|__________________________________________________| 319 320 """ 321 322 # J(0). 323 if search('^[Jj]0$', name) or search('[Jj]$0$', name): 324 return 'j0' 325 326 # F_eta. 327 if search('^[Ff]_[Ee][Tt][Aa]$', name): 328 return 'f_eta' 329 330 # F_R2. 331 if search('^^[Ff]_[Rr]2$', name): 332 return 'f_r2' 333 334 # Bond length. 335 if search('^r$', name) or search('[Bb]ond[ -_][Ll]ength', name): 336 return 'r' 337 338 # CSA. 339 if search('^[Cc][Ss][Aa]$', name): 340 return 'csa' 341 342 # Angle Theta 343 if search('^[Oo][Rr][Ii][Ee][Nn][Tt][Aa][Tt][Ii][Oo][Nn]$', name): 344 return 'orientation' 345 346 # Correlation time 347 if search('^[Tt]c$', name): 348 return 'tc'

349 350

351 - def return_grace_string(self, data_type):

352 """Function for returning the Grace string representing the data type for axis labelling.""" 353 354 # Get the object name. 355 object_name = self.return_data_name(data_type) 356 357 # J(0). 358 if object_name == 'j0': 359 return '\\qJ(0)\\Q' 360 361 # F_eta. 362 elif object_name == 'f_eta': 363 return '\\qF\\s\\xh\\Q' 364 365 # F_R2. 366 elif object_name == 'f_r2': 367 return '\\qF\\sR2\\Q' 368 369 # Bond length. 370 elif object_name == 'r': 371 return 'Bond length' 372 373 # CSA. 374 elif object_name == 'csa': 375 return '\\qCSA\\Q' 376 377 # Angle Theta 378 elif object_name == 'orientation': 379 return '\\q\\xq\\Q' 380 381 # Correlation time 382 elif object_name == 'tc': 383 return '\\q\\xt\\f{}c\\Q'

384 385

386 - def return_units(self, data_type):

387 """Function for returning a string representing the parameters units. 388 389 For example, the internal representation of te is in seconds, whereas the external 390 representation is in picoseconds, therefore this function will return the string 391 'picoseconds' for te. 392 """ 393 394 # Get the object name. 395 object_name = self.return_data_name(data_type) 396 397 # Bond length (Angstrom). 398 if object_name == 'r': 399 return 'Angstrom' 400 401 # CSA (ppm). 402 elif object_name == 'csa': 403 return 'ppm' 404 405 # Angle Theta 406 elif object_name == 'orientation': 407 return 'degrees' 408 409 # Correlation time 410 elif object_name == 'tc': 411 return 'ns'

412 413

414 - def set(self, run=None, value=None, error=None, param=None, index=None):

415 """ 416 Consistency testing set details 417 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 418 419 In consistency testing, only four values can be set, the bond length, CSA, angle 420 Theta ('orientation') and correlation time values. These must be set prior to the 421 calculation of consistency functions. 422 423 """ 424 425 # Arguments. 426 self.run = run 427 428 # Setting the model parameters prior to calculation. 429 #################################################### 430 431 if param == None: 432 # The values are supplied by the user: 433 if value: 434 # Test if the length of the value array is equal to 4. 435 if len(value) != 4: 436 raise RelaxError, "The length of " + `len(value)` + " of the value array must be equal to four." 437 438 # Default values. 439 else: 440 # Set 'value' to an empty array. 441 value = [] 442 443 # CSA, Bond length, Angle Theta and Correlation time. 444 value.append(self.default_value('csa')) 445 value.append(self.default_value('r')) 446 value.append(self.default_value('orientation')) 447 value.append(self.default_value('tc')) 448 449 # Initilise data. 450 if not hasattr(self.relax.data.res[self.run][index], 'csa') or not hasattr(self.relax.data.res[self.run][index], 'r') or not hasattr(self.relax.data.res[self.run][index], 'orientation') or not hasattr(self.relax.data.res[self.run][index], 'tc'): 451 self.data_init(self.relax.data.res[self.run][index]) 452 453 # CSA, bond length, angle Theta and correlation time. 454 setattr(self.relax.data.res[self.run][index], 'csa', float(value[0])) 455 setattr(self.relax.data.res[self.run][index], 'r', float(value[1])) 456 setattr(self.relax.data.res[self.run][index], 'orientation', float(value[2])) 457 setattr(self.relax.data.res[self.run][index], 'tc', float(value[3])) 458 459 460 # Individual data type. 461 ####################### 462 463 else: 464 # Get the object. 465 object_name = self.return_data_name(param) 466 if not object_name: 467 raise RelaxError, "The consistency tests data type " + `param` + " does not exist." 468 469 # Initialise all data if it doesn't exist. 470 if not hasattr(self.relax.data.res[self.run][index], object_name): 471 self.data_init(self.relax.data.res[self.run][index]) 472 473 # Default value. 474 if value == None: 475 value = self.default_value(object_name) 476 477 # Set the value. 478 setattr(self.relax.data.res[self.run][index], object_name, float(value)) 479 480 # Set the error. 481 if error != None: 482 setattr(self.relax.data.res[self.run][index], object_name+'_err', float(error))

483 484

485 - def set_frq(self, run=None, frq=None):

486 """Function for selecting which relaxation data to use in the consistency tests.""" 487 488 # Run argument. 489 self.run = run 490 491 # Test if the run exists. 492 if not self.run in self.relax.data.run_names: 493 raise RelaxNoRunError, self.run 494 495 # Test if the run type is set to 'ct'. 496 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 497 if function_type != 'ct': 498 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 499 500 # Test if the frequency has been set. 501 if hasattr(self.relax.data, 'ct_frq') and self.relax.data.ct_frq.has_key(self.run): 502 raise RelaxError, "The frequency for the run " + `self.run` + " has already been set." 503 504 # Create the data structure if it doesn't exist. 505 if not hasattr(self.relax.data, 'ct_frq'): 506 self.relax.data.ct_frq = {} 507 508 # Set the frequency. 509 self.relax.data.ct_frq[self.run] = frq

510 511

512 - def set_error(self, run, instance, index, error):

513 """Function for setting parameter errors.""" 514 515 # Arguments. 516 self.run = run 517 518 # Return J(0) sim data. 519 if index == 0: 520 self.relax.data.res[self.run][instance].j0_err = error 521 522 # Return F_eta sim data. 523 if index == 1: 524 self.relax.data.res[self.run][instance].f_eta_err = error 525 526 # Return F_R2 sim data. 527 if index == 2: 528 self.relax.data.res[self.run][instance].f_r2_err = error

529 530

531 - def sim_return_param(self, run, instance, index):

532 """Function for returning the array of simulation parameter values.""" 533 534 # Arguments. 535 self.run = run 536 537 # Skip unselected residues. 538 if not self.relax.data.res[self.run][instance].select: 539 return 540 541 # Return J(0) sim data. 542 if index == 0: 543 return self.relax.data.res[self.run][instance].j0_sim 544 545 # Return F_eta sim data. 546 if index == 1: 547 return self.relax.data.res[self.run][instance].f_eta_sim 548 549 # Return F_R2 sim data. 550 if index == 2: 551 return self.relax.data.res[self.run][instance].f_r2_sim

552 553

554 - def sim_return_selected(self, run, instance):

555 """Function for returning the array of selected simulation flags.""" 556 557 # Arguments. 558 self.run = run 559 560 # Multiple instances. 561 return self.relax.data.res[self.run][instance].select_sim

562 563

564 - def set_selected_sim(self, run, instance, select_sim):

565 """Function for returning the array of selected simulation flags.""" 566 567 # Arguments. 568 self.run = run 569 570 # Multiple instances. 571 self.relax.data.res[self.run][instance].select_sim = select_sim

572 573

574 - def sim_pack_data(self, run, i, sim_data):

575 """Function for packing Monte Carlo simulation data.""" 576 577 # Test if the simulation data already exists. 578 if hasattr(self.relax.data.res[run][i], 'relax_sim_data'): 579 raise RelaxError, "Monte Carlo simulation data already exists." 580 581 # Create the data structure. 582 self.relax.data.res[run][i].relax_sim_data = sim_data

583 584

585 - def write_columnar_line(self, file=None, num=None, name=None, select=None, data_set=None, nucleus=None, wH=None, j0=None, f_eta=None, f_r2=None, r=None, csa=None, orientation=None, tc=None, ri_labels=None, remap_table=None, frq_labels=None, frq=None, ri=None, ri_error=None):

586 """Function for printing a single line of the columnar formatted results.""" 587 588 # Residue number and name. 589 file.write("%-4s %-5s " % (num, name)) 590 591 # Selected flag and data set. 592 file.write("%-9s %-9s " % (select, data_set)) 593 594 # Nucleus. 595 file.write("%-7s " % nucleus) 596 597 # Proton frequency. 598 file.write("%-25s " % wH) 599 600 # Parameters. 601 file.write("%-25s " % j0) 602 file.write("%-25s " % f_eta) 603 file.write("%-25s " % f_r2) 604 file.write("%-25s " % r) 605 file.write("%-25s " % csa) 606 file.write("%-25s " % orientation) 607 file.write("%-25s " % tc) 608 609 # Relaxation data setup. 610 if ri_labels: 611 file.write("%-40s " % ri_labels) 612 file.write("%-25s " % remap_table) 613 file.write("%-25s " % frq_labels) 614 file.write("%-30s " % frq) 615 616 # Relaxation data. 617 if ri: 618 for i in xrange(len(ri)): 619 if ri[i] == None: 620 file.write("%-25s " % 'None') 621 else: 622 file.write("%-25s " % ri[i]) 623 624 # Relaxation errors. 625 if ri_error: 626 for i in xrange(len(ri_error)): 627 if ri_error[i] == None: 628 file.write("%-25s " % 'None') 629 else: 630 file.write("%-25s " % ri_error[i]) 631 632 # End of the line. 633 file.write("\n")

634 635

636 - def write_columnar_results(self, file, run):

637 """Function for printing the results into a file.""" 638 639 # Arguments. 640 self.run = run 641 642 # Test if the run exists. 643 if not self.run in self.relax.data.run_names: 644 raise RelaxNoRunError, self.run 645 646 # Test if sequence data is loaded. 647 if not self.relax.data.res.has_key(self.run): 648 raise RelaxNoSequenceError, self.run 649 650 651 # Header. 652 ######### 653 654 # Relaxation data and errors. 655 ri = [] 656 ri_error = [] 657 if hasattr(self.relax.data, 'num_ri'): 658 for i in xrange(self.relax.data.num_ri[self.run]): 659 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]] + ")") 660 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]] + ")") 661 662 # Write the header line. 663 self.write_columnar_line(file=file, num='Num', name='Name', select='Selected', data_set='Data_set', nucleus='Nucleus', wH='Proton_frq_(MHz)', j0='J(0)', f_eta='F_eta', f_r2='F_R2', r='Bond_length_(A)', csa='CSA_(ppm)', orientation='Angle_Theta_(degrees)', tc='Correlation_time_(ns)', ri_labels='Ri_labels', remap_table='Remap_table', frq_labels='Frq_labels', frq='Frequencies', ri=ri, ri_error=ri_error) 664 665 666 # Values. 667 ######### 668 669 # Nucleus. 670 nucleus = self.relax.generic.nuclei.find_nucleus() 671 672 # The proton frequency in MHz. 673 wH = self.relax.data.ct_frq[self.run] / 1e6 674 675 # Relaxation data setup. 676 try: 677 ri_labels = replace(`self.relax.data.ri_labels[self.run]`, ' ', '') 678 remap_table = replace(`self.relax.data.remap_table[self.run]`, ' ', '') 679 frq_labels = replace(`self.relax.data.frq_labels[self.run]`, ' ', '') 680 frq = replace(`self.relax.data.frq[self.run]`, ' ', '') 681 except AttributeError: 682 ri_labels = `None` 683 remap_table = `None` 684 frq_labels = `None` 685 frq = `None` 686 687 # Loop over the sequence. 688 for i in xrange(len(self.relax.data.res[self.run])): 689 # Reassign data structure. 690 data = self.relax.data.res[self.run][i] 691 692 # J(0). 693 j0 = None 694 if hasattr(data, 'j0'): 695 j0 = data.j0 696 697 # F_eta. 698 f_eta = None 699 if hasattr(data, 'f_eta'): 700 f_eta = data.f_eta 701 702 # F_R2. 703 f_r2 = None 704 if hasattr(data, 'f_r2'): 705 f_r2 = data.f_r2 706 707 # Bond length. 708 r = None 709 if hasattr(data, 'r') and data.r != None: 710 r = data.r / 1e-10 711 712 # CSA. 713 csa = None 714 if hasattr(data, 'csa') and data.csa != None: 715 csa = data.csa / 1e-6 716 717 # Angle Theta 718 orientation = None 719 if hasattr(data, 'orientation') and data.orientation != None: 720 orientation = data.orientation 721 722 # Correlation time 723 tc = None 724 if hasattr(data, 'tc') and data.tc != None: 725 tc = data.tc / 1e-9 726 727 # Relaxation data and errors. 728 ri = [] 729 ri_error = [] 730 if hasattr(self.relax.data, 'num_ri'): 731 for i in xrange(self.relax.data.num_ri[self.run]): 732 try: 733 # Find the residue specific data corresponding to i. 734 index = None 735 for j in xrange(data.num_ri): 736 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]]: 737 index = j 738 739 # Data exists for this data type. 740 ri.append(`data.relax_data[index]`) 741 ri_error.append(`data.relax_error[index]`) 742 743 # No data exists for this data type. 744 except: 745 ri.append(None) 746 ri_error.append(None) 747 748 # Write the line. 749 self.write_columnar_line(file=file, num=data.num, name=data.name, select=data.select, data_set='value', nucleus=nucleus, wH=`wH`, j0=`j0`, f_eta=`f_eta`, f_r2=`f_r2`, r=`r`, csa=`csa`, orientation=`orientation`, tc=`tc`, ri_labels=ri_labels, remap_table=remap_table, frq_labels=frq_labels, frq=frq, ri=ri, ri_error=ri_error) 750 751 752 # Errors. 753 ######### 754 755 # Skip this section and the next if no simulations have been setup. 756 if not hasattr(self.relax.data, 'sim_state'): 757 return 758 elif self.relax.data.sim_state[self.run] == 0: 759 return 760 761 # Loop over the sequence. 762 for i in xrange(len(self.relax.data.res[self.run])): 763 # Reassign data structure. 764 data = self.relax.data.res[self.run][i] 765 766 # J(0). 767 j0 = None 768 if hasattr(data, 'j0_err'): 769 j0 = data.j0_err 770 771 # F_eta. 772 f_eta = None 773 if hasattr(data, 'f_eta_err'): 774 f_eta = data.f_eta_err 775 776 # F_R2. 777 f_r2 = None 778 if hasattr(data, 'f_r2_err'): 779 f_r2 = data.f_r2_err 780 781 # Bond length. 782 r = None 783 if hasattr(data, 'r_err') and data.r_err != None: 784 r = data.r_err / 1e-10 785 786 # CSA. 787 csa = None 788 if hasattr(data, 'csa_err') and data.csa_err != None: 789 csa = data.csa_err / 1e-6 790 791 # Angle Theta. 792 orientation = None 793 if hasattr(data, 'orientation_err') and data.orientation_err != None: 794 orientation = data.orientation_err 795 796 # Correlation time. 797 tc = None 798 if hasattr(data, 'tc_err') and data.tc_err != None: 799 tc = data.tc_err / 1e-6 800 801 # Relaxation data and errors. 802 ri = [] 803 ri_error = [] 804 for i in xrange(self.relax.data.num_ri[self.run]): 805 ri.append(None) 806 ri_error.append(None) 807 808 # Write the line. 809 self.write_columnar_line(file=file, num=data.num, name=data.name, select=data.select, data_set='error', nucleus=nucleus, wH=`wH`, j0=`j0`, f_eta=`f_eta`, f_r2=`f_r2`, r=`r`, csa=`csa`, orientation=`orientation`, tc=`tc`, ri_labels=ri_labels, remap_table=remap_table, frq_labels=frq_labels, frq=frq, ri=ri, ri_error=ri_error) 810 811 812 # Simulation values. 813 #################### 814 815 # Loop over the simulations. 816 for i in xrange(self.relax.data.sim_number[self.run]): 817 # Loop over the sequence. 818 for j in xrange(len(self.relax.data.res[self.run])): 819 # Reassign data structure. 820 data = self.relax.data.res[self.run][j] 821 822 # J(0). 823 j0 = None 824 if hasattr(data, 'j0_sim'): 825 j0 = data.j0_sim[i] 826 827 # F_eta. 828 f_eta = None 829 if hasattr(data, 'f_eta_sim'): 830 f_eta = data.f_eta_sim[i] 831 832 # F_R2. 833 f_r2 = None 834 if hasattr(data, 'f_r2_sim'): 835 f_r2 = data.f_r2_sim[i] 836 837 # Bond length. 838 r = None 839 if hasattr(data, 'r_sim') and data.r_sim != None and data.r_sim[i] != None: 840 r = data.r_sim[i] / 1e-10 841 842 # CSA. 843 csa = None 844 if hasattr(data, 'csa_sim') and data.csa_sim != None and data.csa_sim[i] != None: 845 csa = data.csa_sim[i] / 1e-6 846 847 # Angle Theta. 848 orientation = None 849 if hasattr(data, 'orientation_sim') and data.orientation_sim != None and data.orientation_sim[i] != None: 850 orientation = data.orientation_sim[i] 851 852 # Correlation time. 853 tc = None 854 if hasattr(data, 'tc_sim') and data.tc_sim != None and data.tc_sim[i] != None: 855 tc = data.tc_sim[i] / 1e-6 856 857 # Relaxation data and errors. 858 ri = [] 859 ri_error = [] 860 if hasattr(self.relax.data, 'num_ri'): 861 for k in xrange(self.relax.data.num_ri[self.run]): 862 try: 863 # Find the residue specific data corresponding to k. 864 index = None 865 for l in xrange(data.num_ri): 866 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]]: 867 index = l 868 869 # Data exists for this data type. 870 ri.append(`data.relax_sim_data[i][index]`) 871 ri_error.append(`data.relax_error[index]`) 872 873 # No data exists for this data type. 874 except: 875 ri.append(None) 876 ri_error.append(None) 877 878 # Write the line. 879 self.write_columnar_line(file=file, num=data.num, name=data.name, select=data.select, data_set='sim_'+`i`, nucleus=nucleus, wH=`wH`, j0=`j0`, f_eta=`f_eta`, f_r2=`f_r2`, r=`r`, csa=`csa`, orientation=`orientation`, tc=`tc`, ri_labels=ri_labels, remap_table=remap_table, frq_labels=frq_labels, frq=frq, ri=ri, ri_error=ri_error)

Source Code for Module specific_fns.consistency_tests