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 40 # Test if the run exists. 41 if not self.run in self.relax.data.run_names: 42 raise RelaxNoRunError, self.run 43 44 # Test if sequence data is loaded. 45 if not self.relax.data.res.has_key(self.run): 46 raise RelaxNoSequenceError, self.run 47 48 49 # Global (non-residue specific) data. 50 ##################################### 51 52 # Initialise dictionaries. 53 if not hasattr(self.relax.data, 'ri_labels'): 54 self.relax.data.ri_labels = {} 55 self.relax.data.remap_table = {} 56 self.relax.data.frq_labels = {} 57 self.relax.data.frq = {} 58 self.relax.data.num_ri = {} 59 self.relax.data.num_frq = {} 60 61 # Add the data structures. 62 if not self.relax.data.ri_labels.has_key(self.run): 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 # Remap the data structure 'self.relax.data.res[self.run][res_index]'. 75 data = self.relax.data.res[self.run][res_index] 76 77 # Relaxation data. 78 if not sim: 79 # Initialise the relaxation data structures (if needed). 80 self.initialise_relax_data(data) 81 82 # Relaxation data and errors. 83 data.relax_data = values 84 data.relax_error = errors 85 86 # Associated data structures. 87 data.ri_labels = ri_labels 88 data.remap_table = remap_table 89 data.frq_labels = frq_labels 90 data.frq = frq 91 data.num_ri = len(ri_labels) 92 data.num_frq = len(frq) 93 94 # Create an array of None for the NOE R1 translation table. 95 for i in xrange(data.num_ri): 96 data.noe_r1_table.append(None) 97 98 # Update the NOE R1 translation table. 99 for i in xrange(data.num_ri): 100 # If the data corresponds to 'NOE', try to find if the corresponding R1 data. 101 if data.ri_labels[i] == 'NOE': 102 for j in xrange(data.num_ri): 103 if data.ri_labels[j] == 'R1' and data.frq_labels[data.remap_table[i]] == data.frq_labels[data.remap_table[j]]: 104 data.noe_r1_table[data.num_ri - 1] = j 105 106 # If the data corresponds to 'R1', try to find if the corresponding NOE data. 107 if data.ri_labels[i] == 'R1': 108 for j in xrange(data.num_ri): 109 if data.ri_labels[j] == 'NOE' and data.frq_labels[data.remap_table[i]] == data.frq_labels[data.remap_table[j]]: 110 data.noe_r1_table[j] = data.num_ri - 1 111 112 113 # Simulation data. 114 else: 115 # Create the data structure if necessary. 116 if not hasattr(data, 'relax_sim_data') or type(data.relax_sim_data) != list: 117 data.relax_sim_data = [] 118 119 # Append the simulation's relaxation data. 120 data.relax_sim_data.append(values)

121 122

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

124 """Function for back calculating relaxation data.""" 125 126 # Arguments. 127 self.run = run 128 self.ri_label = ri_label 129 self.frq_label = frq_label 130 self.frq = frq 131 132 # Test if the run exists. 133 if not self.run in self.relax.data.run_names: 134 raise RelaxNoRunError, self.run 135 136 # Test if sequence data is loaded. 137 if not self.relax.data.res.has_key(self.run): 138 raise RelaxNoSequenceError, self.run 139 140 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' already exists. 141 if self.test_labels(run): 142 raise RelaxRiError, (self.ri_label, self.frq_label) 143 144 # Function type. 145 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 146 147 # Specific back-calculate function setup. 148 back_calculate = self.relax.specific_setup.setup('back_calc', function_type) 149 150 # Loop over the sequence. 151 for i in xrange(len(self.relax.data.res[self.run])): 152 # Remap the data structure 'self.relax.data.res[self.run][i]'. 153 data = self.relax.data.res[self.run][i] 154 155 # Store a copy of all the data in 'self.relax.data.res[self.run][i]' for backing up if the back_calculation function fails. 156 back_up = deepcopy(data) 157 158 # Initialise all data structures. 159 self.update_data_structures(data) 160 161 # Back-calculate the relaxation value. 162 try: 163 value = back_calculate(run=self.run, index=i, ri_label=self.ri_label, frq_label=frq_label, frq=self.frq) 164 except: 165 # Restore the data. 166 self.relax.data.res[self.run][i] = deepcopy(back_up) 167 del back_up 168 raise 169 170 # Update all data structures. 171 self.update_data_structures(data, value)

172 173

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

175 """Function for copying relaxation data from run1 to run2.""" 176 177 # Arguments. 178 self.ri_label = ri_label 179 self.frq_label = frq_label 180 181 # Test if run1 exists. 182 if not run1 in self.relax.data.run_names: 183 raise RelaxNoRunError, run1 184 185 # Test if run2 exists. 186 if not run2 in self.relax.data.run_names: 187 raise RelaxNoRunError, run2 188 189 # Test if the sequence data for run1 is loaded. 190 if not self.relax.data.res.has_key(run1): 191 raise RelaxNoSequenceError, run1 192 193 # Test if the sequence data for run2 is loaded. 194 if not self.relax.data.res.has_key(run2): 195 raise RelaxNoSequenceError, run2 196 197 # Copy all data. 198 if ri_label == None and frq_label == None: 199 # Get all data structure names. 200 names = self.data_names() 201 202 # Loop over the sequence. 203 for i in xrange(len(self.relax.data.res[run1])): 204 # Remap the data structure 'self.relax.data.res[run1][i]'. 205 data1 = self.relax.data.res[run1][i] 206 data2 = self.relax.data.res[run2][i] 207 208 # Loop through the data structure names. 209 for name in names: 210 # Skip the data structure if it does not exist. 211 if not hasattr(data1, name): 212 continue 213 214 # Copy the data structure. 215 setattr(data2, name, deepcopy(getattr(data1, name))) 216 217 # Copy a specific data set. 218 else: 219 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' exists for run1. 220 if not self.test_labels(run1): 221 raise RelaxNoRiError, (self.ri_label, self.frq_label) 222 223 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' exists for run2. 224 if self.test_labels(run2): 225 raise RelaxRiError, (self.ri_label, self.frq_label) 226 227 # Loop over the sequence. 228 for i in xrange(len(self.relax.data.res[run1])): 229 # Remap the data structure 'self.relax.data.res[run1][i]'. 230 data1 = self.relax.data.res[run1][i] 231 data2 = self.relax.data.res[run2][i] 232 233 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 234 index = self.find_index(data1) 235 236 # Catch any problems. 237 if index == None: 238 continue 239 240 # Get the value and error from run1. 241 value = data1.relax_data[index] 242 error = data1.relax_error[index] 243 244 # Update all data structures for run2. 245 self.update_data_structures(data2, value, error)

246 247

248 - def data_init(self, name):

249 """Function for returning an initial data structure corresponding to 'name'.""" 250 251 # Empty arrays. 252 list_data = [ 'relax_data', 253 'relax_error', 254 'ri_labels', 255 'remap_table', 256 'noe_r1_table', 257 'frq_labels', 258 'frq' ] 259 if name in list_data: 260 return [] 261 262 # Zero. 263 zero_data = [ 'num_ri', 'num_frq' ] 264 if name in zero_data: 265 return 0

266 267

268 - def data_names(self):

269 """Function for returning a list of names of data structures associated with relax_data. 270 271 Description 272 ~~~~~~~~~~~ 273 274 The names are as follows: 275 276 relax_data: Relaxation data. 277 278 relax_error: Relaxation error. 279 280 num_ri: Number of data points, eg 6. 281 282 num_frq: Number of field strengths, eg 2. 283 284 ri_labels: Labels corresponding to the data type, eg ['NOE', 'R1', 'R2', 'NOE', 'R1', 285 'R2']. 286 287 remap_table: A translation table to map relaxation data points to their frequencies, eg [0, 288 0, 0, 1, 1, 1]. 289 290 noe_r1_table: A translation table to direct the NOE data points to the R1 data points. 291 This is used to speed up calculations by avoiding the recalculation of R1 values. eg [None, 292 None, 0, None, None, 3] 293 294 frq_labels: NMR frequency labels, eg ['600', '500'] 295 296 frq: NMR frequencies in Hz, eg [600.0 * 1e6, 500.0 * 1e6] 297 """ 298 299 names = [ 'relax_data', 300 'relax_error', 301 'num_ri', 302 'num_frq', 303 'ri_labels', 304 'remap_table', 305 'noe_r1_table', 306 'frq_labels', 307 'frq' ] 308 309 return names

310 311

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

313 """Function for deleting relaxation data corresponding to ri_label and frq_label.""" 314 315 # Arguments. 316 self.run = run 317 self.ri_label = ri_label 318 self.frq_label = frq_label 319 320 # Test if the run exists. 321 if not self.run in self.relax.data.run_names: 322 raise RelaxNoRunError, self.run 323 324 # Test if the sequence data is loaded. 325 if not self.relax.data.res.has_key(self.run): 326 raise RelaxNoSequenceError, self.run 327 328 # Test if data corresponding to 'self.ri_label' and 'self.frq_label' exists. 329 if not self.test_labels(run): 330 raise RelaxNoRiError, (self.ri_label, self.frq_label) 331 332 # Loop over the sequence. 333 for i in xrange(len(self.relax.data.res[self.run])): 334 # Remap the data structure 'self.relax.data.res[self.run][i]'. 335 data = self.relax.data.res[self.run][i] 336 337 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 338 index = self.find_index(data) 339 340 # Catch any problems. 341 if index == None: 342 continue 343 344 # Relaxation data and errors. 345 data.relax_data.pop(index) 346 data.relax_error.pop(index) 347 348 # Update the number of relaxation data points. 349 data.num_ri = data.num_ri - 1 350 351 # Delete ri_label from the data types. 352 data.ri_labels.pop(index) 353 354 # Update the remap table. 355 data.remap_table.pop(index) 356 357 # Find if there is other data corresponding to 'self.frq_label' 358 frq_index = data.frq_labels.index(self.frq_label) 359 if not frq_index in data.remap_table: 360 # Update the number of frequencies. 361 data.num_frq = data.num_frq - 1 362 363 # Update the frequency labels. 364 data.frq_labels.pop(frq_index) 365 366 # Update the frequency array. 367 data.frq.pop(frq_index) 368 369 # Update the NOE R1 translation table. 370 data.noe_r1_table.pop(index) 371 for j in xrange(data.num_ri): 372 if data.noe_r1_table[j] > index: 373 data.noe_r1_table[j] = data.noe_r1_table[j] - 1 374 375 # Clean up the runs. 376 self.relax.generic.runs.eliminate_unused_runs()

377 378

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

380 """Function for displaying relaxation data corresponding to ri_label and frq_label.""" 381 382 # Arguments. 383 self.run = run 384 self.ri_label = ri_label 385 self.frq_label = frq_label 386 387 # Test if the run exists. 388 if not self.run in self.relax.data.run_names: 389 raise RelaxNoRunError, self.run 390 391 # Test if the sequence data is loaded. 392 if not self.relax.data.res.has_key(self.run): 393 raise RelaxNoSequenceError, self.run 394 395 # Test if data corresponding to 'self.ri_label' and 'self.frq_label' exists. 396 if not self.test_labels(run): 397 raise RelaxNoRiError, (self.ri_label, self.frq_label) 398 399 # Print the data. 400 self.relax.generic.value.write_data(self.run, (self.ri_label, self.frq_label), sys.stdout, return_value=self.return_value)

401 402

403 - def find_index(self, data):

404 """Function for finding the index corresponding to self.ri_label and self.frq_label.""" 405 406 # No data.num_ri data structure. 407 if not hasattr(data, 'num_ri'): 408 return None 409 410 # Find the index. 411 index = None 412 for j in xrange(data.num_ri): 413 if self.ri_label == data.ri_labels[j] and self.frq_label == data.frq_labels[data.remap_table[j]]: 414 index = j 415 416 # Return the index. 417 return index

418 419

420 - def initialise_relax_data(self, data):

421 """Function for initialisation of relaxation data structures. 422 423 Only data structures which do not exist are created. 424 """ 425 426 # Get the data names. 427 data_names = self.data_names() 428 429 # Loop over the names. 430 for name in data_names: 431 # If the name is not in 'data', add it. 432 if not hasattr(data, name): 433 setattr(data, name, self.data_init(name))

434 435

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

437 """Function for reading R1, R2, or NOE relaxation data.""" 438 439 # Arguments. 440 self.run = run 441 self.ri_label = ri_label 442 self.frq_label = frq_label 443 self.frq = frq 444 445 # Test if the run exists. 446 if not self.run in self.relax.data.run_names: 447 raise RelaxNoRunError, self.run 448 449 # Test if sequence data is loaded. 450 if not self.relax.data.res.has_key(self.run): 451 raise RelaxNoSequenceError, self.run 452 453 # Test if relaxation data corresponding to 'self.ri_label' and 'self.frq_label' already exists. 454 if self.test_labels(run): 455 raise RelaxRiError, (self.ri_label, self.frq_label) 456 457 # Extract the data from the file. 458 if not file_data: 459 # Extract. 460 file_data = self.relax.IO.extract_data(file, dir) 461 462 # Count the number of header lines. 463 header_lines = 0 464 for i in xrange(len(file_data)): 465 try: 466 int(file_data[i][num_col]) 467 except: 468 header_lines = header_lines + 1 469 else: 470 break 471 472 # Remove the header. 473 file_data = file_data[header_lines:] 474 475 # Strip the data. 476 file_data = self.relax.IO.strip(file_data) 477 478 # Test the validity of the relaxation data. 479 for i in xrange(len(file_data)): 480 try: 481 int(file_data[i][num_col]) 482 eval(file_data[i][data_col]) 483 eval(file_data[i][error_col]) 484 except ValueError: 485 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] + ")." 486 487 488 # Global (non-residue specific) data. 489 ##################################### 490 491 # Initialise dictionaries. 492 if not hasattr(self.relax.data, 'ri_labels'): 493 self.relax.data.ri_labels = {} 494 self.relax.data.remap_table = {} 495 self.relax.data.frq_labels = {} 496 self.relax.data.frq = {} 497 self.relax.data.num_ri = {} 498 self.relax.data.num_frq = {} 499 500 # Initialise empty data structures. 501 if not self.relax.data.ri_labels.has_key(self.run): 502 self.relax.data.ri_labels[self.run] = [] 503 self.relax.data.remap_table[self.run] = [] 504 self.relax.data.frq_labels[self.run] = [] 505 self.relax.data.frq[self.run] = [] 506 self.relax.data.num_ri[self.run] = 0 507 self.relax.data.num_frq[self.run] = 0 508 509 # The index. 510 i = len(self.relax.data.ri_labels[self.run]) - 1 511 512 # Update the number of relaxation data points. 513 self.relax.data.num_ri[self.run] = self.relax.data.num_ri[self.run] + 1 514 515 # Add ri_label to the data types. 516 self.relax.data.ri_labels[self.run].append(self.ri_label) 517 518 # Find if the frequency self.frq has already been loaded. 519 remap = len(self.relax.data.frq[self.run]) 520 flag = 0 521 for j in xrange(len(self.relax.data.frq[self.run])): 522 if self.frq == self.relax.data.frq[self.run][j]: 523 remap = j 524 flag = 1 525 526 # Update the remap table. 527 self.relax.data.remap_table[self.run].append(remap) 528 529 # Update the data structures which have a length equal to the number of field strengths. 530 if not flag: 531 # Update the number of frequencies. 532 self.relax.data.num_frq[self.run] = self.relax.data.num_frq[self.run] + 1 533 534 # Update the frequency labels. 535 self.relax.data.frq_labels[self.run].append(self.frq_label) 536 537 # Update the frequency array. 538 self.relax.data.frq[self.run].append(self.frq) 539 540 541 # Residue specific data. 542 ######################## 543 544 # Store the indecies for which relaxation data has been added. 545 index_list = [] 546 547 # Loop over the relaxation data. 548 for i in xrange(len(file_data)): 549 # Convert the data. 550 res_num = int(file_data[i][num_col]) 551 res_name = file_data[i][name_col] 552 value = eval(file_data[i][data_col]) 553 error = eval(file_data[i][error_col]) 554 555 # Skip all rows where the value or error is None. 556 if value == None or error == None: 557 continue 558 559 # Find the index of self.relax.data.res[self.run] which corresponds to the relaxation data set i. 560 index = None 561 for j in xrange(len(self.relax.data.res[self.run])): 562 if self.relax.data.res[self.run][j].num == res_num and self.relax.data.res[self.run][j].name == res_name: 563 index = j 564 break 565 if index == None: 566 raise RelaxNoResError, (res_num, res_name) 567 568 # Remap the data structure 'self.relax.data.res[self.run][index]'. 569 data = self.relax.data.res[self.run][index] 570 571 # Update all data structures. 572 self.update_data_structures(data, value, error) 573 574 # Add the index to the list. 575 index_list.append(index) 576 577 578 # Selection flag. 579 ################# 580 581 # Loop over the sequence. 582 for index in xrange(len(self.relax.data.res[self.run])): 583 # Remap the data structure 'self.relax.data.res[self.run][index]'. 584 data = self.relax.data.res[self.run][index] 585 586 # No data loaded for this residue. 587 if index not in index_list: 588 # If no relaxation data exists, unselect the residue. 589 if not hasattr(data, 'relax_data'): 590 data.select = 0

591 592

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

594 """Function for returning the value and error corresponding to 'data_type'.""" 595 596 # Arguments. 597 self.run = run 598 599 # Unpack the data_type tuple. 600 self.ri_label, self.frq_label = data_type 601 602 # Initialise. 603 value = None 604 error = None 605 606 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 607 index = self.find_index(self.relax.data.res[self.run][i]) 608 609 # Get the data. 610 if index != None: 611 value = self.relax.data.res[self.run][i].relax_data[index] 612 error = self.relax.data.res[self.run][i].relax_error[index] 613 614 # Return the data. 615 return value, error

616 617

618 - def test_labels(self, run):

619 """Test if data corresponding to 'self.ri_label' and 'self.frq_label' currently exists.""" 620 621 # Initialise. 622 exists = 0 623 624 # Loop over the sequence. 625 for i in xrange(len(self.relax.data.res[run])): 626 # Remap the data structure 'self.relax.data.res[run][i]'. 627 data = self.relax.data.res[run][i] 628 629 # No ri data. 630 if not hasattr(data, 'num_ri'): 631 continue 632 633 # Loop over the relaxation data. 634 for j in xrange(data.num_ri): 635 # Test if the relaxation data matches 'self.ri_label' and 'self.frq_label'. 636 if self.ri_label == data.ri_labels[j] and self.frq_label == data.frq_labels[data.remap_table[j]]: 637 exists = 1 638 639 return exists

640 641

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

643 """Function for updating all relaxation data structures.""" 644 645 # Initialise the relaxation data structures (if needed). 646 self.initialise_relax_data(data) 647 648 # Find the index corresponding to 'self.ri_label' and 'self.frq_label'. 649 index = self.find_index(data) 650 651 # Append empty data. 652 if index == None: 653 data.relax_data.append(None) 654 data.relax_error.append(None) 655 data.ri_labels.append(None) 656 data.remap_table.append(None) 657 data.noe_r1_table.append(None) 658 659 # Set the index value. 660 if index == None: 661 i = len(data.relax_data) - 1 662 else: 663 i = index 664 665 # Relaxation data and errors. 666 data.relax_data[i] = value 667 data.relax_error[i] = error 668 669 # Update the number of relaxation data points. 670 if index == None: 671 data.num_ri = data.num_ri + 1 672 673 # Add ri_label to the data types. 674 data.ri_labels[i] = self.ri_label 675 676 # Find if the frequency self.frq has already been loaded. 677 remap = len(data.frq) 678 flag = 0 679 for j in xrange(len(data.frq)): 680 if self.frq == data.frq[j]: 681 remap = j 682 flag = 1 683 684 # Update the remap table. 685 data.remap_table[i] = remap 686 687 # Update the data structures which have a length equal to the number of field strengths. 688 if not flag: 689 # Update the number of frequencies. 690 if index == None: 691 data.num_frq = data.num_frq + 1 692 693 # Update the frequency labels. 694 data.frq_labels.append(self.frq_label) 695 696 # Update the frequency array. 697 data.frq.append(self.frq) 698 699 # Update the NOE R1 translation table. 700 # If the data corresponds to 'NOE', try to find if the corresponding R1 data. 701 if self.ri_label == 'NOE': 702 for j in xrange(data.num_ri): 703 if data.ri_labels[j] == 'R1' and self.frq_label == data.frq_labels[data.remap_table[j]]: 704 data.noe_r1_table[data.num_ri - 1] = j 705 706 # Update the NOE R1 translation table. 707 # If the data corresponds to 'R1', try to find if the corresponding NOE data. 708 if self.ri_label == 'R1': 709 for j in xrange(data.num_ri): 710 if data.ri_labels[j] == 'NOE' and self.frq_label == data.frq_labels[data.remap_table[j]]: 711 data.noe_r1_table[j] = data.num_ri - 1

712 713

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

715 """Function for writing relaxation data.""" 716 717 # Arguments. 718 self.run = run 719 self.ri_label = ri_label 720 self.frq_label = frq_label 721 722 # Test if the run exists. 723 if not self.run in self.relax.data.run_names: 724 raise RelaxNoRunError, self.run 725 726 # Test if the sequence data is loaded. 727 if not self.relax.data.res.has_key(self.run): 728 raise RelaxNoSequenceError, self.run 729 730 # Test if data corresponding to 'self.ri_label' and 'self.frq_label' exists. 731 if not self.test_labels(run): 732 raise RelaxNoRiError, (self.ri_label, self.frq_label) 733 734 # Create the file name if none is given. 735 if file == None: 736 file = self.ri_label + "." + self.frq_label + ".out" 737 738 # Open the file for writing. 739 relax_file = self.relax.IO.open_write_file(file, dir, force) 740 741 # Write the data. 742 self.relax.generic.value.write_data(self.run, (self.ri_label, self.frq_label), relax_file, return_value=self.return_value) 743 744 # Close the file. 745 relax_file.close()

Source Code for Module specific_fns.relax_data