specific_fns.relax

28 - def __init__(self, relax):

29 """Class containing functions for relaxation data.""" 30 31 self.relax = relax 32 33 # Global data flag (default to residue specific data). 34 self.global_flag = 0

35 36

37 - def add_residue(self, run=None, res_index=None, ri_labels=None, remap_table=None, frq_labels=None, frq=None, values=None, errors=None, sim=0):

38 """Function for adding all relaxation data for a single residue.""" 39 40 # Arguments. 41 self.run = run 42 self.ri_labels = ri_labels 43 self.remap_table = remap_table 44 self.frq_labels = frq_labels 45 self.frq = frq 46 47 # Test if the run exists. 48 if not self.run in self.relax.data.run_names: 49 raise RelaxNoRunError, self.run 50 51 # Test if sequence data is loaded. 52 if not self.relax.data.res.has_key(self.run): 53 raise RelaxNoSequenceError, self.run 54 55 56 # Global (non-residue specific) data. 57 ##################################### 58 59 # Global data flag. 60 self.global_flag = 1 61 62 # Initialise the global data if necessary. 63 self.data_init(self.relax.data) 64 65 # Add the data structures. 66 self.relax.data.ri_labels[self.run] = deepcopy(ri_labels) 67 self.relax.data.remap_table[self.run] = deepcopy(remap_table) 68 self.relax.data.frq_labels[self.run] = deepcopy(frq_labels) 69 self.relax.data.frq[self.run] = deepcopy(frq) 70 self.relax.data.num_ri[self.run] = len(ri_labels) 71 self.relax.data.num_frq[self.run] = len(frq) 72 73 74 # Residue specific data. 75 ######################## 76 77 # Global data flag. 78 self.global_flag = 0 79 80 # Remap the data structure 'self.relax.data.res[self.run][res_index]'. 81 data = self.relax.data.res[self.run][res_index] 82 83 # Relaxation data. 84 if not sim: 85 # Initialise the relaxation data structures (if needed). 86 self.data_init(data) 87 88 # Relaxation data and errors. 89 data.relax_data = values 90 data.relax_error = errors 91 92 # Associated data structures. 93 data.ri_labels = ri_labels 94 data.remap_table = remap_table 95 96 # Remove any data with the value None. 97 for index,Ri in enumerate(data.relax_data): 98 if Ri == None: 99 data.relax_data.pop(index) 100 data.relax_error.pop(index) 101 data.ri_labels.pop(index) 102 data.remap_table.pop(index) 103 104 # Remove any data with error of None. 105 for index,error in enumerate(data.relax_error): 106 if error == None: 107 data.relax_data.pop(index) 108 data.relax_error.pop(index) 109 data.ri_labels.pop(index) 110 data.remap_table.pop(index) 111 112 # Associated data structures. 113 data.frq_labels = frq_labels 114 data.frq = frq 115 data.num_ri = len(ri_labels) 116 data.num_frq = len(frq) 117 118 # Create an array of None for the NOE R1 translation table. 119 for i in xrange(data.num_ri): 120 data.noe_r1_table.append(None) 121 122 # Update the NOE R1 translation table. 123 for i in xrange(data.num_ri): 124 # If the data corresponds to 'NOE', try to find if the corresponding R1 data. 125 if data.ri_labels[i] == 'NOE': 126 for j in xrange(data.num_ri): 127 if data.ri_labels[j] == 'R1' and data.frq_labels[data.remap_table[i]] == data.frq_labels[data.remap_table[j]]: 128 data.noe_r1_table[i] = j 129 130 # If the data corresponds to 'R1', try to find if the corresponding NOE data. 131 if data.ri_labels[i] == 'R1': 132 for j in xrange(data.num_ri): 133 if data.ri_labels[j] == 'NOE' and data.frq_labels[data.remap_table[i]] == data.frq_labels[data.remap_table[j]]: 134 data.noe_r1_table[j] = i 135 136 137 # Simulation data. 138 else: 139 # Create the data structure if necessary. 140 if not hasattr(data, 'relax_sim_data') or type(data.relax_sim_data) != list: 141 data.relax_sim_data = [] 142 143 # Append the simulation's relaxation data. 144 data.relax_sim_data.append(values)

145 146

147 - def back_calc(self, run=None, ri_label=None, frq_label=None, frq=None):

148 """Function for back calculating relaxation data.""" 149 150 # Arguments. 151 self.run = run 152 self.ri_label = ri_label 153 self.frq_label = frq_label 154 self.frq = frq 155 156 # Test if the run exists. 157 if not self.run in self.relax.data.run_names: 158 raise RelaxNoRunError, self.run 159 160 # Test if sequence data is loaded. 161 if not self.relax.data.res.has_key(self.run): 162 raise RelaxNoSequenceError, self.run 163 164 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' already exists. 165 if self.test_labels(run): 166 raise RelaxRiError, (self.ri_label, self.frq_label) 167 168 169 # Global (non-residue specific) data. 170 ##################################### 171 172 # Global data flag. 173 self.global_flag = 1 174 175 # Initialise the global data if necessary. 176 self.data_init(self.relax.data) 177 178 # Update the global data. 179 self.update_global_data_structures() 180 181 182 # Residue specific data. 183 ######################## 184 185 # Global data flag. 186 self.global_flag = 0 187 188 # Function type. 189 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 190 191 # Specific back-calculate function setup. 192 back_calculate = self.relax.specific_setup.setup('back_calc', function_type) 193 194 # Loop over the sequence. 195 for i in xrange(len(self.relax.data.res[self.run])): 196 # Remap the data structure 'self.relax.data.res[self.run][i]'. 197 data = self.relax.data.res[self.run][i] 198 199 # Skip unselected residues. 200 if not data.select: 201 continue 202 203 # Store a copy of all the data in 'self.relax.data.res[self.run][i]' for backing up if the back_calculation function fails. 204 back_up = deepcopy(data) 205 206 # Initialise all data structures. 207 self.update_data_structures(data) 208 209 # Back-calculate the relaxation value. 210 try: 211 value = back_calculate(run=self.run, index=i, ri_label=self.ri_label, frq_label=frq_label, frq=self.frq) 212 except: 213 # Restore the data. 214 self.relax.data.res[self.run][i] = deepcopy(back_up) 215 del back_up 216 raise 217 218 # Update all data structures. 219 self.update_data_structures(data, value)

220 221

222 - def copy(self, run1=None, run2=None, ri_label=None, frq_label=None):

223 """Function for copying relaxation data from run1 to run2.""" 224 225 # Arguments. 226 self.ri_label = ri_label 227 self.frq_label = frq_label 228 229 # Test if run1 exists. 230 if not run1 in self.relax.data.run_names: 231 raise RelaxNoRunError, run1 232 233 # Test if run2 exists. 234 if not run2 in self.relax.data.run_names: 235 raise RelaxNoRunError, run2 236 237 # Test if the sequence data for run1 is loaded. 238 if not self.relax.data.res.has_key(run1): 239 raise RelaxNoSequenceError, run1 240 241 # Test if the sequence data for run2 is loaded. 242 if not self.relax.data.res.has_key(run2): 243 raise RelaxNoSequenceError, run2 244 245 # Copy all data. 246 if ri_label == None and frq_label == None: 247 # Get all data structure names. 248 names = self.data_names() 249 250 # Loop over the sequence. 251 for i in xrange(len(self.relax.data.res[run1])): 252 # Remap the data structure 'self.relax.data.res[run1][i]'. 253 data1 = self.relax.data.res[run1][i] 254 data2 = self.relax.data.res[run2][i] 255 256 # Loop through the data structure names. 257 for name in names: 258 # Skip the data structure if it does not exist. 259 if not hasattr(data1, name): 260 continue 261 262 # Copy the data structure. 263 setattr(data2, name, deepcopy(getattr(data1, name))) 264 265 # Copy a specific data set. 266 else: 267 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' exists for run1. 268 if not self.test_labels(run1): 269 raise RelaxNoRiError, (self.ri_label, self.frq_label) 270 271 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' exists for run2. 272 if self.test_labels(run2): 273 raise RelaxRiError, (self.ri_label, self.frq_label) 274 275 # Loop over the sequence. 276 for i in xrange(len(self.relax.data.res[run1])): 277 # Remap the data structure 'self.relax.data.res[run1][i]'. 278 data1 = self.relax.data.res[run1][i] 279 data2 = self.relax.data.res[run2][i] 280 281 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 282 index = self.find_index(data1) 283 284 # Catch any problems. 285 if index == None: 286 continue 287 288 # Get the value and error from run1. 289 value = data1.relax_data[index] 290 error = data1.relax_error[index] 291 292 # Update all data structures for run2. 293 self.update_data_structures(data2, value, error)

294 295

296 - def data_init(self, data):

297 """Function for initialising the data structures.""" 298 299 # Get the data names. 300 data_names = self.data_names() 301 302 # Loop over the data structure names. 303 for name in data_names: 304 # Global data. 305 if self.global_flag == 1: 306 # Add the global data structure if it does not exist. 307 if not hasattr(data, name): 308 setattr(data, name, {}) 309 310 # Data structures which are initially empty arrays. 311 list_data = [ 'relax_data', 312 'relax_error', 313 'ri_labels', 314 'remap_table', 315 'noe_r1_table', 316 'frq_labels', 317 'frq' ] 318 if name in list_data: 319 # Global data. 320 if self.global_flag == 1: 321 # Get the object. 322 object = getattr(data, name) 323 324 # Add the data if the key is missing. 325 if not object.has_key(self.run): 326 object[self.run] = [] 327 328 # Residue specific data. 329 else: 330 # If the name is not in 'data', add it. 331 if not hasattr(data, name): 332 setattr(data, name, []) 333 334 # Data structures which are initially zero. 335 zero_data = [ 'num_ri', 'num_frq' ] 336 if name in zero_data: 337 # Global data. 338 if self.global_flag == 1: 339 # Get the object. 340 object = getattr(data, name) 341 342 # Add the data if the key is missing. 343 if not object.has_key(self.run): 344 object[self.run] = 0 345 346 # Residue specific data. 347 else: 348 # If the name is not in 'data', add it. 349 if not hasattr(data, name): 350 setattr(data, name, 0)

351 352

353 - def data_names(self):

354 """Function for returning a list of names of data structures associated with relax_data. 355 356 Description 357 ~~~~~~~~~~~ 358 359 The names are as follows: 360 361 relax_data: Relaxation data. 362 363 relax_error: Relaxation error. 364 365 num_ri: Number of data points, eg 6. 366 367 num_frq: Number of field strengths, eg 2. 368 369 ri_labels: Labels corresponding to the data type, eg ['NOE', 'R1', 'R2', 'NOE', 'R1', 370 'R2']. 371 372 remap_table: A translation table to map relaxation data points to their frequencies, eg [0, 373 0, 0, 1, 1, 1]. 374 375 noe_r1_table: A translation table to direct the NOE data points to the R1 data points. 376 This is used to speed up calculations by avoiding the recalculation of R1 values. eg [None, 377 None, 0, None, None, 3] 378 379 frq_labels: NMR frequency labels, eg ['600', '500'] 380 381 frq: NMR frequencies in Hz, eg [600.0 * 1e6, 500.0 * 1e6] 382 """ 383 384 # Global data names. 385 if self.global_flag == 1: 386 names = [ 'num_ri', 387 'num_frq', 388 'ri_labels', 389 'remap_table', 390 'noe_r1_table', 391 'frq_labels', 392 'frq' ] 393 394 # Residue specific data names. 395 else: 396 names = [ 'relax_data', 397 'relax_error', 398 'num_ri', 399 'num_frq', 400 'ri_labels', 401 'remap_table', 402 'noe_r1_table', 403 'frq_labels', 404 'frq' ] 405 406 return names

407 408

409 - def delete(self, run=None, ri_label=None, frq_label=None):

410 """Function for deleting relaxation data corresponding to ri_label and frq_label.""" 411 412 # Arguments. 413 self.run = run 414 self.ri_label = ri_label 415 self.frq_label = frq_label 416 417 # Test if the run exists. 418 if not self.run in self.relax.data.run_names: 419 raise RelaxNoRunError, self.run 420 421 # Test if the sequence data is loaded. 422 if not self.relax.data.res.has_key(self.run): 423 raise RelaxNoSequenceError, self.run 424 425 # Test if data corresponding to 'self.ri_label' and 'self.frq_label' exists. 426 if not self.test_labels(run): 427 raise RelaxNoRiError, (self.ri_label, self.frq_label) 428 429 # Loop over the sequence. 430 for i in xrange(len(self.relax.data.res[self.run])): 431 # Remap the data structure 'self.relax.data.res[self.run][i]'. 432 data = self.relax.data.res[self.run][i] 433 434 # Global data flag. 435 self.global_flag = 0 436 437 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 438 index = self.find_index(data) 439 440 # Catch any problems. 441 if index == None: 442 continue 443 444 # Relaxation data and errors. 445 data.relax_data.pop(index) 446 data.relax_error.pop(index) 447 448 # Update the number of relaxation data points. 449 data.num_ri = data.num_ri - 1 450 451 # Delete ri_label from the data types. 452 data.ri_labels.pop(index) 453 454 # Update the remap table. 455 data.remap_table.pop(index) 456 457 # Find if there is other data corresponding to 'self.frq_label' 458 frq_index = data.frq_labels.index(self.frq_label) 459 if not frq_index in data.remap_table: 460 # Update the number of frequencies. 461 data.num_frq = data.num_frq - 1 462 463 # Update the frequency labels. 464 data.frq_labels.pop(frq_index) 465 466 # Update the frequency array. 467 data.frq.pop(frq_index) 468 469 # Update the NOE R1 translation table. 470 data.noe_r1_table.pop(index) 471 for j in xrange(data.num_ri): 472 if data.noe_r1_table[j] > index: 473 data.noe_r1_table[j] = data.noe_r1_table[j] - 1 474 475 # Clean up the runs. 476 self.relax.generic.runs.eliminate_unused_runs()

477 478

479 - def display(self, run=None, ri_label=None, frq_label=None):

480 """Function for displaying relaxation data corresponding to ri_label and frq_label.""" 481 482 # Arguments. 483 self.run = run 484 self.ri_label = ri_label 485 self.frq_label = frq_label 486 487 # Test if the run exists. 488 if not self.run in self.relax.data.run_names: 489 raise RelaxNoRunError, self.run 490 491 # Test if the sequence data is loaded. 492 if not self.relax.data.res.has_key(self.run): 493 raise RelaxNoSequenceError, self.run 494 495 # Test if data corresponding to 'self.ri_label' and 'self.frq_label' exists. 496 if not self.test_labels(run): 497 raise RelaxNoRiError, (self.ri_label, self.frq_label) 498 499 # Print the data. 500 self.relax.generic.value.write_data(run=self.run, param=(self.ri_label, self.frq_label), file=sys.stdout, return_value=self.return_value)

501 502

503 - def find_index(self, data):

504 """Function for finding the index corresponding to self.ri_label and self.frq_label.""" 505 506 # No data.num_ri data structure. 507 if self.global_flag == 1: 508 if not data.num_ri.has_key(self.relax): 509 return None 510 else: 511 if not hasattr(data, 'num_ri'): 512 return None 513 514 # Initialise. 515 index = None 516 517 # Find the index. 518 if self.global_flag == 1: 519 for j in xrange(data.num_ri[self.run]): 520 if self.ri_label == data.ri_labels[self.run][j] and self.frq_label == data.frq_labels[self.run][data.remap_table[self.run][j]]: 521 index = j 522 else: 523 for j in xrange(data.num_ri): 524 if self.ri_label == data.ri_labels[j] and self.frq_label == data.frq_labels[data.remap_table[j]]: 525 index = j 526 527 # Return the index. 528 return index

529 530

531 - def read(self, run=None, ri_label=None, frq_label=None, frq=None, file=None, dir=None, file_data=None, num_col=0, name_col=1, data_col=2, error_col=3, sep=None):

532 """Function for reading R1, R2, or NOE relaxation data.""" 533 534 # Arguments. 535 self.run = run 536 self.ri_label = ri_label 537 self.frq_label = frq_label 538 self.frq = frq 539 540 # Test if the run exists. 541 if not self.run in self.relax.data.run_names: 542 raise RelaxNoRunError, self.run 543 544 # Test if sequence data is loaded. 545 if not self.relax.data.res.has_key(self.run): 546 raise RelaxNoSequenceError, self.run 547 548 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' already exists. 549 if self.test_labels(run): 550 raise RelaxRiError, (self.ri_label, self.frq_label) 551 552 # Minimum number of columns. 553 min_col_num = max(num_col, name_col, data_col, error_col) 554 555 # Extract the data from the file. 556 if not file_data: 557 # Extract. 558 file_data = self.relax.IO.extract_data(file, dir) 559 560 # Count the number of header lines. 561 header_lines = 0 562 for i in xrange(len(file_data)): 563 try: 564 int(file_data[i][num_col]) 565 except: 566 header_lines = header_lines + 1 567 else: 568 break 569 570 # Remove the header. 571 file_data = file_data[header_lines:] 572 573 # Strip the data. 574 file_data = self.relax.IO.strip(file_data) 575 576 # Test the validity of the relaxation data. 577 for i in xrange(len(file_data)): 578 # Skip missing data. 579 if len(file_data[i]) <= min_col_num: 580 continue 581 elif file_data[i][data_col] == 'None' or file_data[i][error_col] == 'None': 582 continue 583 584 # Test that the data are numbers. 585 try: 586 int(file_data[i][num_col]) 587 float(file_data[i][data_col]) 588 float(file_data[i][error_col]) 589 except ValueError: 590 raise RelaxError, "The relaxation data is invalid (num=" + file_data[i][num_col] + ", name=" + file_data[i][name_col] + ", data=" + file_data[i][data_col] + ", error=" + file_data[i][error_col] + ")." 591 592 593 # Global (non-residue specific) data. 594 ##################################### 595 596 # Global data flag. 597 self.global_flag = 1 598 599 # Initialise the global data if necessary. 600 self.data_init(self.relax.data) 601 602 # Update the global data. 603 self.update_global_data_structures() 604 605 606 # Residue specific data. 607 ######################## 608 609 # Global data flag. 610 self.global_flag = 0 611 612 # Store the indecies for which relaxation data has been added. 613 index_list = [] 614 615 # Loop over the relaxation data. 616 for i in xrange(len(file_data)): 617 # Skip missing data. 618 if len(file_data[i]) <= min_col_num: 619 continue 620 621 # Convert the data. 622 res_num = int(file_data[i][num_col]) 623 res_name = file_data[i][name_col] 624 value = eval(file_data[i][data_col]) 625 error = eval(file_data[i][error_col]) 626 627 # Skip all rows where the value or error is None. 628 if value == None or error == None: 629 continue 630 631 # Find the index of self.relax.data.res[self.run] which corresponds to the relaxation data set i. 632 index = None 633 for j in xrange(len(self.relax.data.res[self.run])): 634 if self.relax.data.res[self.run][j].num == res_num and self.relax.data.res[self.run][j].name == res_name: 635 index = j 636 break 637 if index == None: 638 raise RelaxNoResError, (res_num, res_name) 639 640 # Remap the data structure 'self.relax.data.res[self.run][index]'. 641 data = self.relax.data.res[self.run][index] 642 643 # Update all data structures. 644 self.update_data_structures(data, value, error) 645 646 # Add the index to the list. 647 index_list.append(index)

648 649

650 - def return_value(self, run, i, data_type):

651 """Function for returning the value and error corresponding to 'data_type'.""" 652 653 # Arguments. 654 self.run = run 655 656 # Unpack the data_type tuple. 657 self.ri_label, self.frq_label = data_type 658 659 # Initialise. 660 value = None 661 error = None 662 663 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 664 index = self.find_index(self.relax.data.res[self.run][i]) 665 666 # Get the data. 667 if index != None: 668 value = self.relax.data.res[self.run][i].relax_data[index] 669 error = self.relax.data.res[self.run][i].relax_error[index] 670 671 # Return the data. 672 return value, error

673 674

675 - def test_labels(self, run):

676 """Test if data corresponding to 'self.ri_label' and 'self.frq_label' currently exists.""" 677 678 # Initialise. 679 exists = 0 680 681 # Loop over the sequence. 682 for i in xrange(len(self.relax.data.res[run])): 683 # Remap the data structure 'self.relax.data.res[run][i]'. 684 data = self.relax.data.res[run][i] 685 686 # No ri data. 687 if not hasattr(data, 'num_ri'): 688 continue 689 690 # Loop over the relaxation data. 691 for j in xrange(data.num_ri): 692 # Test if the relaxation data matches 'self.ri_label' and 'self.frq_label'. 693 if self.ri_label == data.ri_labels[j] and self.frq_label == data.frq_labels[data.remap_table[j]]: 694 exists = 1 695 696 return exists

697 698

699 - def update_data_structures(self, data=None, value=None, error=None):

700 """Function for updating all relaxation data structures.""" 701 702 # Initialise the relaxation data structures (if needed). 703 self.data_init(data) 704 705 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 706 index = self.find_index(data) 707 708 # Append empty data. 709 if index == None: 710 data.relax_data.append(None) 711 data.relax_error.append(None) 712 data.ri_labels.append(None) 713 data.remap_table.append(None) 714 data.noe_r1_table.append(None) 715 716 # Set the index value. 717 if index == None: 718 i = len(data.relax_data) - 1 719 else: 720 i = index 721 722 # Relaxation data and errors. 723 data.relax_data[i] = value 724 data.relax_error[i] = error 725 726 # Update the number of relaxation data points. 727 if index == None: 728 data.num_ri = data.num_ri + 1 729 730 # Add ri_label to the data types. 731 data.ri_labels[i] = self.ri_label 732 733 # Find if the frequency self.frq has already been loaded. 734 remap = len(data.frq) 735 flag = 0 736 for j in xrange(len(data.frq)): 737 if self.frq == data.frq[j]: 738 remap = j 739 flag = 1 740 741 # Update the remap table. 742 data.remap_table[i] = remap 743 744 # Update the data structures which have a length equal to the number of field strengths. 745 if not flag: 746 # Update the number of frequencies. 747 if index == None: 748 data.num_frq = data.num_frq + 1 749 750 # Update the frequency labels. 751 data.frq_labels.append(self.frq_label) 752 753 # Update the frequency array. 754 data.frq.append(self.frq) 755 756 # Update the NOE R1 translation table. 757 # If the data corresponds to 'NOE', try to find if the corresponding R1 data. 758 if self.ri_label == 'NOE': 759 for j in xrange(data.num_ri): 760 if data.ri_labels[j] == 'R1' and self.frq_label == data.frq_labels[data.remap_table[j]]: 761 data.noe_r1_table[data.num_ri - 1] = j 762 763 # Update the NOE R1 translation table. 764 # If the data corresponds to 'R1', try to find if the corresponding NOE data. 765 if self.ri_label == 'R1': 766 for j in xrange(data.num_ri): 767 if data.ri_labels[j] == 'NOE' and self.frq_label == data.frq_labels[data.remap_table[j]]: 768 data.noe_r1_table[j] = data.num_ri - 1

769 770

771 - def update_global_data_structures(self):

772 """Function for updating all relaxation data structures.""" 773 774 # Initialise the relaxation data structures (if needed). 775 self.data_init(self.relax.data) 776 777 # The index. 778 i = len(self.relax.data.ri_labels[self.run]) - 1 779 780 # Update the number of relaxation data points. 781 self.relax.data.num_ri[self.run] = self.relax.data.num_ri[self.run] + 1 782 783 # Add ri_label to the data types. 784 self.relax.data.ri_labels[self.run].append(self.ri_label) 785 786 # Find if the frequency self.frq has already been loaded. 787 remap = len(self.relax.data.frq[self.run]) 788 flag = 0 789 for j in xrange(len(self.relax.data.frq[self.run])): 790 if self.frq == self.relax.data.frq[self.run][j]: 791 remap = j 792 flag = 1 793 794 # Update the remap table. 795 self.relax.data.remap_table[self.run].append(remap) 796 797 # Update the data structures which have a length equal to the number of field strengths. 798 if not flag: 799 # Update the number of frequencies. 800 self.relax.data.num_frq[self.run] = self.relax.data.num_frq[self.run] + 1 801 802 # Update the frequency labels. 803 self.relax.data.frq_labels[self.run].append(self.frq_label) 804 805 # Update the frequency array. 806 self.relax.data.frq[self.run].append(self.frq) 807 808 # Update the NOE R1 translation table. 809 self.relax.data.noe_r1_table[self.run].append(None) 810 811 # If the data corresponds to 'NOE', try to find if the corresponding R1 data. 812 if self.ri_label == 'NOE': 813 for j in xrange(self.relax.data.num_ri[self.run]): 814 if self.relax.data.ri_labels[self.run][j] == 'R1' and self.frq_label == self.relax.data.frq_labels[self.run][self.relax.data.remap_table[self.run][j]]: 815 self.relax.data.noe_r1_table[self.run][self.relax.data.num_ri[self.run] - 1] = j 816 817 # Update the NOE R1 translation table. 818 # If the data corresponds to 'R1', try to find if the corresponding NOE data. 819 if self.ri_label == 'R1': 820 for j in xrange(self.relax.data.num_ri[self.run]): 821 if self.relax.data.ri_labels[self.run][j] == 'NOE' and self.frq_label == self.relax.data.frq_labels[self.run][self.relax.data.remap_table[self.run][j]]: 822 self.relax.data.noe_r1_table[self.run][j] = self.relax.data.num_ri[self.run] - 1

823 824

825 - def write(self, run=None, ri_label=None, frq_label=None, file=None, dir=None, force=0):

826 """Function for writing relaxation data.""" 827 828 # Arguments. 829 self.run = run 830 self.ri_label = ri_label 831 self.frq_label = frq_label 832 833 # Test if the run exists. 834 if not self.run in self.relax.data.run_names: 835 raise RelaxNoRunError, self.run 836 837 # Test if the sequence data is loaded. 838 if not self.relax.data.res.has_key(self.run): 839 raise RelaxNoSequenceError, self.run 840 841 # Test if data corresponding to 'self.ri_label' and 'self.frq_label' exists. 842 if not self.test_labels(run): 843 raise RelaxNoRiError, (self.ri_label, self.frq_label) 844 845 # Create the file name if none is given. 846 if file == None: 847 file = self.ri_label + "." + self.frq_label + ".out" 848 849 # Write the data. 850 self.relax.generic.value.write(run=self.run, param=(self.ri_label, self.frq_label), file=file, dir=dir, force=force, return_value=self.return_value)

Source Code for Module specific_fns.relax_data