specific_fns.relax

28 - def __init__(self, relax):

29 """Class containing functions for relaxation data.""" 30 31 self.relax = relax

32 33

34 - 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):

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

124 125

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

127 """Function for back calculating relaxation data.""" 128 129 # Arguments. 130 self.run = run 131 self.ri_label = ri_label 132 self.frq_label = frq_label 133 self.frq = frq 134 135 # Test if the run exists. 136 if not self.run in self.relax.data.run_names: 137 raise RelaxNoRunError, self.run 138 139 # Test if sequence data is loaded. 140 if not self.relax.data.res.has_key(self.run): 141 raise RelaxNoSequenceError, self.run 142 143 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' already exists. 144 if self.test_labels(run): 145 raise RelaxRiError, (self.ri_label, self.frq_label) 146 147 148 # Global (non-residue specific) data. 149 ##################################### 150 151 # Global data flag. 152 self.global_flag = 1 153 154 # Initialise the global data if necessary. 155 self.data_init(self.relax.data) 156 157 # Update the global data. 158 self.update_global_data_structures() 159 160 161 # Residue specific data. 162 ######################## 163 164 # Global data flag. 165 self.global_flag = 0 166 167 # Function type. 168 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 169 170 # Specific back-calculate function setup. 171 back_calculate = self.relax.specific_setup.setup('back_calc', function_type) 172 173 # Loop over the sequence. 174 for i in xrange(len(self.relax.data.res[self.run])): 175 # Remap the data structure 'self.relax.data.res[self.run][i]'. 176 data = self.relax.data.res[self.run][i] 177 178 # Store a copy of all the data in 'self.relax.data.res[self.run][i]' for backing up if the back_calculation function fails. 179 back_up = deepcopy(data) 180 181 # Initialise all data structures. 182 self.update_data_structures(data) 183 184 # Back-calculate the relaxation value. 185 try: 186 value = back_calculate(run=self.run, index=i, ri_label=self.ri_label, frq_label=frq_label, frq=self.frq) 187 except: 188 # Restore the data. 189 self.relax.data.res[self.run][i] = deepcopy(back_up) 190 del back_up 191 raise 192 193 # Update all data structures. 194 self.update_data_structures(data, value)

195 196

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

198 """Function for copying relaxation data from run1 to run2.""" 199 200 # Arguments. 201 self.ri_label = ri_label 202 self.frq_label = frq_label 203 204 # Test if run1 exists. 205 if not run1 in self.relax.data.run_names: 206 raise RelaxNoRunError, run1 207 208 # Test if run2 exists. 209 if not run2 in self.relax.data.run_names: 210 raise RelaxNoRunError, run2 211 212 # Test if the sequence data for run1 is loaded. 213 if not self.relax.data.res.has_key(run1): 214 raise RelaxNoSequenceError, run1 215 216 # Test if the sequence data for run2 is loaded. 217 if not self.relax.data.res.has_key(run2): 218 raise RelaxNoSequenceError, run2 219 220 # Copy all data. 221 if ri_label == None and frq_label == None: 222 # Get all data structure names. 223 names = self.data_names() 224 225 # Loop over the sequence. 226 for i in xrange(len(self.relax.data.res[run1])): 227 # Remap the data structure 'self.relax.data.res[run1][i]'. 228 data1 = self.relax.data.res[run1][i] 229 data2 = self.relax.data.res[run2][i] 230 231 # Loop through the data structure names. 232 for name in names: 233 # Skip the data structure if it does not exist. 234 if not hasattr(data1, name): 235 continue 236 237 # Copy the data structure. 238 setattr(data2, name, deepcopy(getattr(data1, name))) 239 240 # Copy a specific data set. 241 else: 242 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' exists for run1. 243 if not self.test_labels(run1): 244 raise RelaxNoRiError, (self.ri_label, self.frq_label) 245 246 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' exists for run2. 247 if self.test_labels(run2): 248 raise RelaxRiError, (self.ri_label, self.frq_label) 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 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 257 index = self.find_index(data1) 258 259 # Catch any problems. 260 if index == None: 261 continue 262 263 # Get the value and error from run1. 264 value = data1.relax_data[index] 265 error = data1.relax_error[index] 266 267 # Update all data structures for run2. 268 self.update_data_structures(data2, value, error)

269 270

271 - def data_init(self, data):

272 """Function for initialising the data structures.""" 273 274 # Get the data names. 275 data_names = self.data_names() 276 277 # Loop over the data structure names. 278 for name in data_names: 279 # Global data. 280 if self.global_flag == 1: 281 # Add the global data structure if it does not exist. 282 if not hasattr(data, name): 283 setattr(data, name, {}) 284 285 # Data structures which are initially empty arrays. 286 list_data = [ 'relax_data', 287 'relax_error', 288 'ri_labels', 289 'remap_table', 290 'noe_r1_table', 291 'frq_labels', 292 'frq' ] 293 if name in list_data: 294 # Global data. 295 if self.global_flag == 1: 296 # Get the object. 297 object = getattr(data, name) 298 299 # Add the data if the key is missing. 300 if not object.has_key(self.run): 301 object[self.run] = [] 302 303 # Residue specific data. 304 else: 305 # If the name is not in 'data', add it. 306 if not hasattr(data, name): 307 setattr(data, name, []) 308 309 # Data structures which are initially zero. 310 zero_data = [ 'num_ri', 'num_frq' ] 311 if name in zero_data: 312 # Global data. 313 if self.global_flag == 1: 314 # Get the object. 315 object = getattr(data, name) 316 317 # Add the data if the key is missing. 318 if not object.has_key(self.run): 319 object[self.run] = 0 320 321 # Residue specific data. 322 else: 323 # If the name is not in 'data', add it. 324 if not hasattr(data, name): 325 setattr(data, name, 0)

326 327

328 - def data_names(self):

329 """Function for returning a list of names of data structures associated with relax_data. 330 331 Description 332 ~~~~~~~~~~~ 333 334 The names are as follows: 335 336 relax_data: Relaxation data. 337 338 relax_error: Relaxation error. 339 340 num_ri: Number of data points, eg 6. 341 342 num_frq: Number of field strengths, eg 2. 343 344 ri_labels: Labels corresponding to the data type, eg ['NOE', 'R1', 'R2', 'NOE', 'R1', 345 'R2']. 346 347 remap_table: A translation table to map relaxation data points to their frequencies, eg [0, 348 0, 0, 1, 1, 1]. 349 350 noe_r1_table: A translation table to direct the NOE data points to the R1 data points. 351 This is used to speed up calculations by avoiding the recalculation of R1 values. eg [None, 352 None, 0, None, None, 3] 353 354 frq_labels: NMR frequency labels, eg ['600', '500'] 355 356 frq: NMR frequencies in Hz, eg [600.0 * 1e6, 500.0 * 1e6] 357 """ 358 359 # Global data names. 360 if self.global_flag == 1: 361 names = [ 'num_ri', 362 'num_frq', 363 'ri_labels', 364 'remap_table', 365 'noe_r1_table', 366 'frq_labels', 367 'frq' ] 368 369 # Residue specific data names. 370 else: 371 names = [ 'relax_data', 372 'relax_error', 373 'num_ri', 374 'num_frq', 375 'ri_labels', 376 'remap_table', 377 'noe_r1_table', 378 'frq_labels', 379 'frq' ] 380 381 return names

382 383

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

385 """Function for deleting relaxation data corresponding to ri_label and frq_label.""" 386 387 # Arguments. 388 self.run = run 389 self.ri_label = ri_label 390 self.frq_label = frq_label 391 392 # Test if the run exists. 393 if not self.run in self.relax.data.run_names: 394 raise RelaxNoRunError, self.run 395 396 # Test if the sequence data is loaded. 397 if not self.relax.data.res.has_key(self.run): 398 raise RelaxNoSequenceError, self.run 399 400 # Test if data corresponding to 'self.ri_label' and 'self.frq_label' exists. 401 if not self.test_labels(run): 402 raise RelaxNoRiError, (self.ri_label, self.frq_label) 403 404 # Loop over the sequence. 405 for i in xrange(len(self.relax.data.res[self.run])): 406 # Remap the data structure 'self.relax.data.res[self.run][i]'. 407 data = self.relax.data.res[self.run][i] 408 409 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 410 index = self.find_index(data) 411 412 # Catch any problems. 413 if index == None: 414 continue 415 416 # Relaxation data and errors. 417 data.relax_data.pop(index) 418 data.relax_error.pop(index) 419 420 # Update the number of relaxation data points. 421 data.num_ri = data.num_ri - 1 422 423 # Delete ri_label from the data types. 424 data.ri_labels.pop(index) 425 426 # Update the remap table. 427 data.remap_table.pop(index) 428 429 # Find if there is other data corresponding to 'self.frq_label' 430 frq_index = data.frq_labels.index(self.frq_label) 431 if not frq_index in data.remap_table: 432 # Update the number of frequencies. 433 data.num_frq = data.num_frq - 1 434 435 # Update the frequency labels. 436 data.frq_labels.pop(frq_index) 437 438 # Update the frequency array. 439 data.frq.pop(frq_index) 440 441 # Update the NOE R1 translation table. 442 data.noe_r1_table.pop(index) 443 for j in xrange(data.num_ri): 444 if data.noe_r1_table[j] > index: 445 data.noe_r1_table[j] = data.noe_r1_table[j] - 1 446 447 # Clean up the runs. 448 self.relax.generic.runs.eliminate_unused_runs()

449 450

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

452 """Function for displaying relaxation data corresponding to ri_label and frq_label.""" 453 454 # Arguments. 455 self.run = run 456 self.ri_label = ri_label 457 self.frq_label = frq_label 458 459 # Test if the run exists. 460 if not self.run in self.relax.data.run_names: 461 raise RelaxNoRunError, self.run 462 463 # Test if the sequence data is loaded. 464 if not self.relax.data.res.has_key(self.run): 465 raise RelaxNoSequenceError, self.run 466 467 # Test if data corresponding to 'self.ri_label' and 'self.frq_label' exists. 468 if not self.test_labels(run): 469 raise RelaxNoRiError, (self.ri_label, self.frq_label) 470 471 # Print the data. 472 self.relax.generic.value.write_data(self.run, (self.ri_label, self.frq_label), sys.stdout, return_value=self.return_value)

473 474

475 - def find_index(self, data):

476 """Function for finding the index corresponding to self.ri_label and self.frq_label.""" 477 478 # No data.num_ri data structure. 479 if self.global_flag == 1: 480 if not data.num_ri.has_key(self.relax): 481 return None 482 else: 483 if not hasattr(data, 'num_ri'): 484 return None 485 486 # Initialise. 487 index = None 488 489 # Find the index. 490 if self.global_flag == 1: 491 for j in xrange(data.num_ri[self.run]): 492 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]]: 493 index = j 494 else: 495 for j in xrange(data.num_ri): 496 if self.ri_label == data.ri_labels[j] and self.frq_label == data.frq_labels[data.remap_table[j]]: 497 index = j 498 499 # Return the index. 500 return index

501 502

503 - 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):

504 """Function for reading R1, R2, or NOE relaxation data.""" 505 506 # Arguments. 507 self.run = run 508 self.ri_label = ri_label 509 self.frq_label = frq_label 510 self.frq = frq 511 512 # Test if the run exists. 513 if not self.run in self.relax.data.run_names: 514 raise RelaxNoRunError, self.run 515 516 # Test if sequence data is loaded. 517 if not self.relax.data.res.has_key(self.run): 518 raise RelaxNoSequenceError, self.run 519 520 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' already exists. 521 if self.test_labels(run): 522 raise RelaxRiError, (self.ri_label, self.frq_label) 523 524 # Extract the data from the file. 525 if not file_data: 526 # Extract. 527 file_data = self.relax.IO.extract_data(file, dir) 528 529 # Count the number of header lines. 530 header_lines = 0 531 for i in xrange(len(file_data)): 532 try: 533 int(file_data[i][num_col]) 534 except: 535 header_lines = header_lines + 1 536 else: 537 break 538 539 # Remove the header. 540 file_data = file_data[header_lines:] 541 542 # Strip the data. 543 file_data = self.relax.IO.strip(file_data) 544 545 # Test the validity of the relaxation data. 546 for i in xrange(len(file_data)): 547 try: 548 int(file_data[i][num_col]) 549 eval(file_data[i][data_col]) 550 eval(file_data[i][error_col]) 551 except ValueError: 552 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] + ")." 553 554 555 # Global (non-residue specific) data. 556 ##################################### 557 558 # Global data flag. 559 self.global_flag = 1 560 561 # Initialise the global data if necessary. 562 self.data_init(self.relax.data) 563 564 # Update the global data. 565 self.update_global_data_structures() 566 567 568 # Residue specific data. 569 ######################## 570 571 # Global data flag. 572 self.global_flag = 0 573 574 # Store the indecies for which relaxation data has been added. 575 index_list = [] 576 577 # Loop over the relaxation data. 578 for i in xrange(len(file_data)): 579 # Convert the data. 580 res_num = int(file_data[i][num_col]) 581 res_name = file_data[i][name_col] 582 value = eval(file_data[i][data_col]) 583 error = eval(file_data[i][error_col]) 584 585 # Skip all rows where the value or error is None. 586 if value == None or error == None: 587 continue 588 589 # Find the index of self.relax.data.res[self.run] which corresponds to the relaxation data set i. 590 index = None 591 for j in xrange(len(self.relax.data.res[self.run])): 592 if self.relax.data.res[self.run][j].num == res_num and self.relax.data.res[self.run][j].name == res_name: 593 index = j 594 break 595 if index == None: 596 raise RelaxNoResError, (res_num, res_name) 597 598 # Remap the data structure 'self.relax.data.res[self.run][index]'. 599 data = self.relax.data.res[self.run][index] 600 601 # Update all data structures. 602 self.update_data_structures(data, value, error) 603 604 # Add the index to the list. 605 index_list.append(index) 606 607 608 # Selection flag. 609 ################# 610 611 # Loop over the sequence. 612 for index in xrange(len(self.relax.data.res[self.run])): 613 # Remap the data structure 'self.relax.data.res[self.run][index]'. 614 data = self.relax.data.res[self.run][index] 615 616 # No data loaded for this residue. 617 if index not in index_list: 618 # If no relaxation data exists, unselect the residue. 619 if not hasattr(data, 'relax_data'): 620 data.select = 0

621 622

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

624 """Function for returning the value and error corresponding to 'data_type'.""" 625 626 # Arguments. 627 self.run = run 628 629 # Unpack the data_type tuple. 630 self.ri_label, self.frq_label = data_type 631 632 # Initialise. 633 value = None 634 error = None 635 636 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 637 index = self.find_index(self.relax.data.res[self.run][i]) 638 639 # Get the data. 640 if index != None: 641 value = self.relax.data.res[self.run][i].relax_data[index] 642 error = self.relax.data.res[self.run][i].relax_error[index] 643 644 # Return the data. 645 return value, error

646 647

648 - def test_labels(self, run):

649 """Test if data corresponding to 'self.ri_label' and 'self.frq_label' currently exists.""" 650 651 # Initialise. 652 exists = 0 653 654 # Loop over the sequence. 655 for i in xrange(len(self.relax.data.res[run])): 656 # Remap the data structure 'self.relax.data.res[run][i]'. 657 data = self.relax.data.res[run][i] 658 659 # No ri data. 660 if not hasattr(data, 'num_ri'): 661 continue 662 663 # Loop over the relaxation data. 664 for j in xrange(data.num_ri): 665 # Test if the relaxation data matches 'self.ri_label' and 'self.frq_label'. 666 if self.ri_label == data.ri_labels[j] and self.frq_label == data.frq_labels[data.remap_table[j]]: 667 exists = 1 668 669 return exists

670 671

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

673 """Function for updating all relaxation data structures.""" 674 675 # Initialise the relaxation data structures (if needed). 676 self.data_init(data) 677 678 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 679 index = self.find_index(data) 680 681 # Append empty data. 682 if index == None: 683 data.relax_data.append(None) 684 data.relax_error.append(None) 685 data.ri_labels.append(None) 686 data.remap_table.append(None) 687 data.noe_r1_table.append(None) 688 689 # Set the index value. 690 if index == None: 691 i = len(data.relax_data) - 1 692 else: 693 i = index 694 695 # Relaxation data and errors. 696 data.relax_data[i] = value 697 data.relax_error[i] = error 698 699 # Update the number of relaxation data points. 700 if index == None: 701 data.num_ri = data.num_ri + 1 702 703 # Add ri_label to the data types. 704 data.ri_labels[i] = self.ri_label 705 706 # Find if the frequency self.frq has already been loaded. 707 remap = len(data.frq) 708 flag = 0 709 for j in xrange(len(data.frq)): 710 if self.frq == data.frq[j]: 711 remap = j 712 flag = 1 713 714 # Update the remap table. 715 data.remap_table[i] = remap 716 717 # Update the data structures which have a length equal to the number of field strengths. 718 if not flag: 719 # Update the number of frequencies. 720 if index == None: 721 data.num_frq = data.num_frq + 1 722 723 # Update the frequency labels. 724 data.frq_labels.append(self.frq_label) 725 726 # Update the frequency array. 727 data.frq.append(self.frq) 728 729 # Update the NOE R1 translation table. 730 # If the data corresponds to 'NOE', try to find if the corresponding R1 data. 731 if self.ri_label == 'NOE': 732 for j in xrange(data.num_ri): 733 if data.ri_labels[j] == 'R1' and self.frq_label == data.frq_labels[data.remap_table[j]]: 734 data.noe_r1_table[data.num_ri - 1] = j 735 736 # Update the NOE R1 translation table. 737 # If the data corresponds to 'R1', try to find if the corresponding NOE data. 738 if self.ri_label == 'R1': 739 for j in xrange(data.num_ri): 740 if data.ri_labels[j] == 'NOE' and self.frq_label == data.frq_labels[data.remap_table[j]]: 741 data.noe_r1_table[j] = data.num_ri - 1

742 743

744 - def update_global_data_structures(self):

745 """Function for updating all relaxation data structures.""" 746 747 # Initialise the relaxation data structures (if needed). 748 self.data_init(self.relax.data) 749 750 # The index. 751 i = len(self.relax.data.ri_labels[self.run]) - 1 752 753 # Update the number of relaxation data points. 754 self.relax.data.num_ri[self.run] = self.relax.data.num_ri[self.run] + 1 755 756 # Add ri_label to the data types. 757 self.relax.data.ri_labels[self.run].append(self.ri_label) 758 759 # Find if the frequency self.frq has already been loaded. 760 remap = len(self.relax.data.frq[self.run]) 761 flag = 0 762 for j in xrange(len(self.relax.data.frq[self.run])): 763 if self.frq == self.relax.data.frq[self.run][j]: 764 remap = j 765 flag = 1 766 767 # Update the remap table. 768 self.relax.data.remap_table[self.run].append(remap) 769 770 # Update the data structures which have a length equal to the number of field strengths. 771 if not flag: 772 # Update the number of frequencies. 773 self.relax.data.num_frq[self.run] = self.relax.data.num_frq[self.run] + 1 774 775 # Update the frequency labels. 776 self.relax.data.frq_labels[self.run].append(self.frq_label) 777 778 # Update the frequency array. 779 self.relax.data.frq[self.run].append(self.frq) 780 781 # Update the NOE R1 translation table. 782 self.relax.data.noe_r1_table[self.run].append(None) 783 784 # If the data corresponds to 'NOE', try to find if the corresponding R1 data. 785 if self.ri_label == 'NOE': 786 for j in xrange(self.relax.data.num_ri[self.run]): 787 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]]: 788 self.relax.data.noe_r1_table[self.run][self.relax.data.num_ri[self.run] - 1] = j 789 790 # Update the NOE R1 translation table. 791 # If the data corresponds to 'R1', try to find if the corresponding NOE data. 792 if self.ri_label == 'R1': 793 for j in xrange(self.relax.data.num_ri[self.run]): 794 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]]: 795 self.relax.data.noe_r1_table[self.run][j] = self.relax.data.num_ri[self.run] - 1

796 797

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

799 """Function for writing relaxation data.""" 800 801 # Arguments. 802 self.run = run 803 self.ri_label = ri_label 804 self.frq_label = frq_label 805 806 # Test if the run exists. 807 if not self.run in self.relax.data.run_names: 808 raise RelaxNoRunError, self.run 809 810 # Test if the sequence data is loaded. 811 if not self.relax.data.res.has_key(self.run): 812 raise RelaxNoSequenceError, self.run 813 814 # Test if data corresponding to 'self.ri_label' and 'self.frq_label' exists. 815 if not self.test_labels(run): 816 raise RelaxNoRiError, (self.ri_label, self.frq_label) 817 818 # Create the file name if none is given. 819 if file == None: 820 file = self.ri_label + "." + self.frq_label + ".out" 821 822 # Open the file for writing. 823 relax_file = self.relax.IO.open_write_file(file, dir, force) 824 825 # Write the data. 826 self.relax.generic.value.write_data(self.run, (self.ri_label, self.frq_label), relax_file, return_value=self.return_value) 827 828 # Close the file. 829 relax_file.close()

Source Code for Module specific_fns.relax_data