specific_fns.model

37 - def __init__(self, relax):

38 """Class containing functions specific to model-free analysis.""" 39 40 self.relax = relax

41 42

43 - def are_mf_params_set(self, index=None):

44 """Function for testing if the model-free parameter values are set.""" 45 46 # Alias the data structure. 47 data = self.relax.data.res[self.run][index] 48 49 # Unselected residue. 50 if data.select == 0: 51 return 52 53 # Loop over the model-free parameters. 54 for j in xrange(len(data.params)): 55 # tm. 56 if data.params[j] == 'tm' and data.tm == None: 57 return data.params[j] 58 59 # S2. 60 elif data.params[j] == 'S2' and data.s2 == None: 61 return data.params[j] 62 63 # S2f. 64 elif data.params[j] == 'S2f' and data.s2f == None: 65 return data.params[j] 66 67 # S2s. 68 elif data.params[j] == 'S2s' and data.s2s == None: 69 return data.params[j] 70 71 # te. 72 elif data.params[j] == 'te' and data.te == None: 73 return data.params[j] 74 75 # tf. 76 elif data.params[j] == 'tf' and data.tf == None: 77 return data.params[j] 78 79 # ts. 80 elif data.params[j] == 'ts' and data.ts == None: 81 return data.params[j] 82 83 # Rex. 84 elif data.params[j] == 'Rex' and data.rex == None: 85 return data.params[j] 86 87 # r. 88 elif data.params[j] == 'r' and data.r == None: 89 return data.params[j] 90 91 # CSA. 92 elif data.params[j] == 'CSA' and data.csa == None: 93 return data.params[j]

94 95

96 - def assemble_param_names(self, index=None):

97 """Function for assembling various pieces of data into a Numeric parameter array.""" 98 99 # Initialise. 100 self.param_names = [] 101 102 # Diffusion tensor parameters. 103 if self.param_set == 'diff' or self.param_set == 'all': 104 # Isotropic diffusion. 105 if self.relax.data.diff[self.run].type == 'iso': 106 self.param_names.append('tm') 107 108 # Axially symmetric diffusion. 109 elif self.relax.data.diff[self.run].type == 'axial': 110 self.param_names.append('tm') 111 self.param_names.append('Da') 112 self.param_names.append('theta') 113 self.param_names.append('phi') 114 115 # Anisotropic diffusion. 116 elif self.relax.data.diff[self.run].type == 'aniso': 117 self.param_names.append('tm') 118 self.param_names.append('Da') 119 self.param_names.append('Dr') 120 self.param_names.append('alpha') 121 self.param_names.append('beta') 122 self.param_names.append('gamma') 123 124 # Model-free parameters (residue specific parameters). 125 if self.param_set != 'diff': 126 for i in xrange(len(self.relax.data.res[self.run])): 127 # Only add parameters for a single residue if index has a value. 128 if index != None and i != index: 129 continue 130 131 # Skip unselected residues. 132 if not self.relax.data.res[self.run][i].select: 133 continue 134 135 # Loop over the model-free parameters and add the names. 136 for j in xrange(len(self.relax.data.res[self.run][i].params)): 137 self.param_names.append(self.relax.data.res[self.run][i].params[j])

138 139

140 - def assemble_param_vector(self, index=None, sim_index=None, param_set=None):

141 """Function for assembling various pieces of data into a Numeric parameter array.""" 142 143 # Initialise. 144 param_vector = [] 145 if param_set == None: 146 param_set = self.param_set 147 148 # Monte Carlo diffusion tensor parameters. 149 if sim_index != None and (param_set == 'diff' or param_set == 'all'): 150 # Isotropic diffusion. 151 if self.relax.data.diff[self.run].type == 'iso': 152 param_vector.append(self.relax.data.diff[self.run].tm_sim[sim_index]) 153 154 # Axially symmetric diffusion. 155 elif self.relax.data.diff[self.run].type == 'axial': 156 param_vector.append(self.relax.data.diff[self.run].tm_sim[sim_index]) 157 param_vector.append(self.relax.data.diff[self.run].Da_sim[sim_index]) 158 param_vector.append(self.relax.data.diff[self.run].theta_sim[sim_index]) 159 param_vector.append(self.relax.data.diff[self.run].phi_sim[sim_index]) 160 161 # Anisotropic diffusion. 162 elif self.relax.data.diff[self.run].type == 'aniso': 163 param_vector.append(self.relax.data.diff[self.run].tm_sim[sim_index]) 164 param_vector.append(self.relax.data.diff[self.run].Da_sim[sim_index]) 165 param_vector.append(self.relax.data.diff[self.run].Dr_sim[sim_index]) 166 param_vector.append(self.relax.data.diff[self.run].alpha_sim[sim_index]) 167 param_vector.append(self.relax.data.diff[self.run].beta_sim[sim_index]) 168 param_vector.append(self.relax.data.diff[self.run].gamma_sim[sim_index]) 169 170 # Diffusion tensor parameters. 171 elif param_set == 'diff' or param_set == 'all': 172 # Isotropic diffusion. 173 if self.relax.data.diff[self.run].type == 'iso': 174 param_vector.append(self.relax.data.diff[self.run].tm) 175 176 # Axially symmetric diffusion. 177 elif self.relax.data.diff[self.run].type == 'axial': 178 param_vector.append(self.relax.data.diff[self.run].tm) 179 param_vector.append(self.relax.data.diff[self.run].Da) 180 param_vector.append(self.relax.data.diff[self.run].theta) 181 param_vector.append(self.relax.data.diff[self.run].phi) 182 183 # Anisotropic diffusion. 184 elif self.relax.data.diff[self.run].type == 'aniso': 185 param_vector.append(self.relax.data.diff[self.run].tm) 186 param_vector.append(self.relax.data.diff[self.run].Da) 187 param_vector.append(self.relax.data.diff[self.run].Dr) 188 param_vector.append(self.relax.data.diff[self.run].alpha) 189 param_vector.append(self.relax.data.diff[self.run].beta) 190 param_vector.append(self.relax.data.diff[self.run].gamma) 191 192 # Model-free parameters (residue specific parameters). 193 if param_set != 'diff': 194 for i in xrange(len(self.relax.data.res[self.run])): 195 # Skip unselected residues. 196 if not self.relax.data.res[self.run][i].select: 197 continue 198 199 # Only add parameters for a single residue if index has a value. 200 if (param_set == 'mf' or param_set == 'local_tm') and index != None and i != index: 201 continue 202 203 # Loop over the model-free parameters. 204 for j in xrange(len(self.relax.data.res[self.run][i].params)): 205 # tm. 206 if self.relax.data.res[self.run][i].params[j] == 'tm': 207 if self.relax.data.res[self.run][i].tm == None: 208 param_vector.append(0.0) 209 elif sim_index != None: 210 param_vector.append(self.relax.data.res[self.run][i].tm_sim[sim_index]) 211 else: 212 param_vector.append(self.relax.data.res[self.run][i].tm) 213 214 # S2. 215 elif self.relax.data.res[self.run][i].params[j] == 'S2': 216 if self.relax.data.res[self.run][i].s2 == None: 217 param_vector.append(0.0) 218 elif sim_index != None: 219 param_vector.append(self.relax.data.res[self.run][i].s2_sim[sim_index]) 220 else: 221 param_vector.append(self.relax.data.res[self.run][i].s2) 222 223 # S2f. 224 elif self.relax.data.res[self.run][i].params[j] == 'S2f': 225 if self.relax.data.res[self.run][i].s2f == None: 226 param_vector.append(0.0) 227 elif sim_index != None: 228 param_vector.append(self.relax.data.res[self.run][i].s2f_sim[sim_index]) 229 else: 230 param_vector.append(self.relax.data.res[self.run][i].s2f) 231 232 # S2s. 233 elif self.relax.data.res[self.run][i].params[j] == 'S2s': 234 if self.relax.data.res[self.run][i].s2s == None: 235 param_vector.append(0.0) 236 elif sim_index != None: 237 param_vector.append(self.relax.data.res[self.run][i].s2s_sim[sim_index]) 238 else: 239 param_vector.append(self.relax.data.res[self.run][i].s2s) 240 241 # te. 242 elif self.relax.data.res[self.run][i].params[j] == 'te': 243 if self.relax.data.res[self.run][i].te == None: 244 param_vector.append(0.0) 245 elif sim_index != None: 246 param_vector.append(self.relax.data.res[self.run][i].te_sim[sim_index]) 247 else: 248 param_vector.append(self.relax.data.res[self.run][i].te) 249 250 # tf. 251 elif self.relax.data.res[self.run][i].params[j] == 'tf': 252 if self.relax.data.res[self.run][i].tf == None: 253 param_vector.append(0.0) 254 elif sim_index != None: 255 param_vector.append(self.relax.data.res[self.run][i].tf_sim[sim_index]) 256 else: 257 param_vector.append(self.relax.data.res[self.run][i].tf) 258 259 # ts. 260 elif self.relax.data.res[self.run][i].params[j] == 'ts': 261 if self.relax.data.res[self.run][i].ts == None: 262 param_vector.append(0.0) 263 elif sim_index != None: 264 param_vector.append(self.relax.data.res[self.run][i].ts_sim[sim_index]) 265 else: 266 param_vector.append(self.relax.data.res[self.run][i].ts) 267 268 # Rex. 269 elif self.relax.data.res[self.run][i].params[j] == 'Rex': 270 if self.relax.data.res[self.run][i].rex == None: 271 param_vector.append(0.0) 272 elif sim_index != None: 273 param_vector.append(self.relax.data.res[self.run][i].rex_sim[sim_index]) 274 else: 275 param_vector.append(self.relax.data.res[self.run][i].rex) 276 277 # r. 278 elif self.relax.data.res[self.run][i].params[j] == 'r': 279 if self.relax.data.res[self.run][i].r == None: 280 param_vector.append(0.0) 281 elif sim_index != None: 282 param_vector.append(self.relax.data.res[self.run][i].r_sim[sim_index]) 283 else: 284 param_vector.append(self.relax.data.res[self.run][i].r) 285 286 # CSA. 287 elif self.relax.data.res[self.run][i].params[j] == 'CSA': 288 if self.relax.data.res[self.run][i].csa == None: 289 param_vector.append(0.0) 290 elif sim_index != None: 291 param_vector.append(self.relax.data.res[self.run][i].csa_sim[sim_index]) 292 else: 293 param_vector.append(self.relax.data.res[self.run][i].csa) 294 295 # Unknown parameter. 296 else: 297 raise RelaxError, "Unknown parameter." 298 299 # Return a Numeric array. 300 return array(param_vector, Float64)

301 302

303 - def assemble_scaling_matrix(self, index=None, scaling=1):

304 """Function for creating the scaling matrix.""" 305 306 # Initialise. 307 self.scaling_matrix = identity(len(self.param_vector), Float64) 308 i = 0 309 310 # No diagonal scaling. 311 if not scaling: 312 return 313 314 # Diffusion tensor parameters. 315 if self.param_set == 'diff' or self.param_set == 'all': 316 # Isotropic diffusion. 317 if self.relax.data.diff[self.run].type == 'iso': 318 # tm. 319 self.scaling_matrix[i, i] = 1e-9 320 321 # Increment i. 322 i = i + 1 323 324 # Axially symmetric diffusion. 325 elif self.relax.data.diff[self.run].type == 'axial': 326 # tm, Da, theta, phi 327 self.scaling_matrix[i, i] = 1e-9 328 self.scaling_matrix[i+1, i+1] = 1e7 329 self.scaling_matrix[i+2, i+2] = 1.0 330 self.scaling_matrix[i+3, i+3] = 1.0 331 332 # Increment i. 333 i = i + 4 334 335 # Anisotropic diffusion. 336 elif self.relax.data.diff[self.run].type == 'aniso': 337 # tm, Da, Dr, alpha, beta, gamma. 338 self.scaling_matrix[i, i] = 1e-9 339 self.scaling_matrix[i+1, i+1] = 1e7 340 self.scaling_matrix[i+2, i+2] = 1e7 341 self.scaling_matrix[i+3, i+3] = 1.0 342 self.scaling_matrix[i+4, i+4] = 1.0 343 self.scaling_matrix[i+5, i+5] = 1.0 344 345 # Increment i. 346 i = i + 6 347 348 # Model-free parameters. 349 if self.param_set != 'diff': 350 # Loop over all residues. 351 for j in xrange(len(self.relax.data.res[self.run])): 352 # Skip unselected residues. 353 if not self.relax.data.res[self.run][j].select: 354 continue 355 356 # Only add parameters for a single residue if index has a value. 357 if index != None and j != index: 358 continue 359 360 # Loop over the model-free parameters. 361 for k in xrange(len(self.relax.data.res[self.run][j].params)): 362 # tm. 363 if self.relax.data.res[self.run][j].params[k] == 'tm': 364 self.scaling_matrix[i, i] = 1e-9 365 366 # te, tf, and ts. 367 elif match('t', self.relax.data.res[self.run][j].params[k]): 368 self.scaling_matrix[i, i] = 1e-9 369 370 # Rex. 371 elif self.relax.data.res[self.run][j].params[k] == 'Rex': 372 self.scaling_matrix[i, i] = 1.0 / (2.0 * pi * self.relax.data.res[self.run][j].frq[0]) ** 2 373 374 # Bond length. 375 elif self.relax.data.res[self.run][j].params[k] == 'r': 376 self.scaling_matrix[i, i] = 1e-10 377 378 # CSA. 379 elif self.relax.data.res[self.run][j].params[k] == 'CSA': 380 self.scaling_matrix[i, i] = 1e-4 381 382 # Increment i. 383 i = i + 1

384 385

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

387 """Back-calculation of relaxation data from the model-free parameter values.""" 388 389 # Run argument. 390 self.run = run 391 392 # Get the relaxation value from the minimise function. 393 value = self.minimise(run=self.run, min_algor='back_calc', min_options=(index, ri_label, frq_label, frq)) 394 395 # Return the relaxation value. 396 return value

397 398

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

400 """Calculation of the model-free chi-squared value.""" 401 402 # Run argument. 403 self.run = run 404 405 # Go to the minimise function. 406 self.minimise(run=self.run, min_algor='calc', min_options=res_num, sim_index=sim_index)

407 408

409 - def copy(self, run1=None, run2=None, sim=None):

410 """Function for copying all model-free data from run1 to run2.""" 411 412 # Test if run1 exists. 413 if not run1 in self.relax.data.run_names: 414 raise RelaxNoRunError, run1 415 416 # Test if run2 exists. 417 if not run2 in self.relax.data.run_names: 418 raise RelaxNoRunError, run2 419 420 # Test if the run type of run1 is set to 'mf'. 421 function_type = self.relax.data.run_types[self.relax.data.run_names.index(run1)] 422 if function_type != 'mf': 423 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 424 425 # Test if the run type of run2 is set to 'mf'. 426 function_type = self.relax.data.run_types[self.relax.data.run_names.index(run2)] 427 if function_type != 'mf': 428 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 429 430 # Test if the sequence data for run1 is loaded. 431 if not self.relax.data.res.has_key(run1): 432 raise RelaxNoSequenceError, run1 433 434 # Test if the sequence data for run2 is loaded. 435 if not self.relax.data.res.has_key(run2): 436 raise RelaxNoSequenceError, run2 437 438 # Get all data structure names. 439 names = self.data_names() 440 441 # Copy the data. 442 for i in xrange(len(self.relax.data.res[run1])): 443 # Remap the data structure 'self.relax.data.res[run1][i]'. 444 data1 = self.relax.data.res[run1][i] 445 data2 = self.relax.data.res[run2][i] 446 447 # Loop through the data structure names. 448 for name in names: 449 # All data. 450 if not sim: 451 # Skip the data structure if it does not exist. 452 if not hasattr(data1, name): 453 continue 454 455 # Copy the data structure. 456 setattr(data2, name, deepcopy(getattr(data1, name))) 457 458 # Copy just the simulation data for the simulation 'sim'. 459 else: 460 # Sim data name 461 name = name + '_sim' 462 463 # Skip the data structure if it does not exist in both runs. 464 if not hasattr(data1, name) or not hasattr(data2, name): 465 continue 466 467 # Get the objects. 468 object1 = getattr(data1, name) 469 object2 = getattr(data2, name) 470 471 # Copy the data. 472 object2[sim] = object1[sim]

473 474

475 - def create_mc_data(self, run, i):

476 """Function for creating the Monte Carlo Ri data.""" 477 478 # Arguments 479 self.run = run 480 481 # Initialise the data data structure. 482 data = [] 483 484 # Test if the model is set. 485 if not hasattr(self.relax.data.res[self.run][i], 'model') or not self.relax.data.res[self.run][i].model: 486 raise RelaxNoMfModelError, self.run 487 488 # Loop over the relaxation data. 489 for j in xrange(len(self.relax.data.res[run][i].relax_data)): 490 # Back calculate the value. 491 value = self.back_calc(run=run, index=i, ri_label=self.relax.data.res[run][i].ri_labels[j], frq_label=self.relax.data.res[run][i].frq_labels[self.relax.data.res[run][i].remap_table[j]], frq=self.relax.data.res[run][i].frq[self.relax.data.res[run][i].remap_table[j]]) 492 493 # Append the value. 494 data.append(value) 495 496 # Return the data. 497 return data

498 499

500 - def create_model(self, run=None, model=None, equation=None, params=None, res_num=None):

501 """Function to create a model-free model.""" 502 503 # Run argument. 504 self.run = run 505 506 # Test if the run exists. 507 if not self.run in self.relax.data.run_names: 508 raise RelaxNoRunError, self.run 509 510 # Test if the run type is set to 'mf'. 511 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 512 if function_type != 'mf': 513 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 514 515 # Test if sequence data is loaded. 516 if not self.relax.data.res.has_key(self.run): 517 raise RelaxNoSequenceError, self.run 518 519 # Check the validity of the model-free equation type. 520 valid_types = ['mf_orig', 'mf_ext', 'mf_ext2'] 521 if not equation in valid_types: 522 raise RelaxError, "The model-free equation type argument " + `equation` + " is invalid and should be one of " + `valid_types` + "." 523 524 # Check the validity of the parameter array. 525 s2, te, s2f, tf, s2s, ts, rex, csa, r = 0, 0, 0, 0, 0, 0, 0, 0, 0 526 for i in xrange(len(params)): 527 # Invalid parameter flag. 528 invalid_param = 0 529 530 # S2. 531 if params[i] == 'S2': 532 # Does the array contain more than one instance of S2. 533 if s2: 534 invalid_param = 1 535 s2 = 1 536 537 # Does the array contain S2s. 538 s2s_flag = 0 539 for j in xrange(len(params)): 540 if params[j] == 'S2s': 541 s2s_flag = 1 542 if s2s_flag: 543 invalid_param = 1 544 545 # te. 546 elif params[i] == 'te': 547 # Does the array contain more than one instance of te and has the extended model-free formula been selected. 548 if equation == 'mf_ext' or te: 549 invalid_param = 1 550 te = 1 551 552 # Does the array contain the parameter S2. 553 s2_flag = 0 554 for j in xrange(len(params)): 555 if params[j] == 'S2': 556 s2_flag = 1 557 if not s2_flag: 558 invalid_param = 1 559 560 # S2f. 561 elif params[i] == 'S2f': 562 # Does the array contain more than one instance of S2f and has the original model-free formula been selected. 563 if equation == 'mf_orig' or s2f: 564 invalid_param = 1 565 s2f = 1 566 567 # S2s. 568 elif params[i] == 'S2s': 569 # Does the array contain more than one instance of S2s and has the original model-free formula been selected. 570 if equation == 'mf_orig' or s2s: 571 invalid_param = 1 572 s2s = 1 573 574 # tf. 575 elif params[i] == 'tf': 576 # Does the array contain more than one instance of tf and has the original model-free formula been selected. 577 if equation == 'mf_orig' or tf: 578 invalid_param = 1 579 tf = 1 580 581 # Does the array contain the parameter S2f. 582 s2f_flag = 0 583 for j in xrange(len(params)): 584 if params[j] == 'S2f': 585 s2f_flag = 1 586 if not s2f_flag: 587 invalid_param = 1 588 589 # ts. 590 elif params[i] == 'ts': 591 # Does the array contain more than one instance of ts and has the original model-free formula been selected. 592 if equation == 'mf_orig' or ts: 593 invalid_param = 1 594 ts = 1 595 596 # Does the array contain the parameter S2 or S2s. 597 flag = 0 598 for j in xrange(len(params)): 599 if params[j] == 'S2' or params[j] == 'S2f': 600 flag = 1 601 if not flag: 602 invalid_param = 1 603 604 # Rex. 605 elif params[i] == 'Rex': 606 if rex: 607 invalid_param = 1 608 rex = 1 609 610 # Bond length. 611 elif params[i] == 'r': 612 if r: 613 invalid_param = 1 614 r = 1 615 616 # CSA. 617 elif params[i] == 'CSA': 618 if csa: 619 invalid_param = 1 620 csa = 1 621 622 # Unknown parameter. 623 else: 624 raise RelaxError, "The parameter " + params[i] + " is not supported." 625 626 # The invalid parameter flag is set. 627 if invalid_param: 628 raise RelaxError, "The parameter array " + `params` + " contains an invalid combination of parameters." 629 630 # Set up the model. 631 self.model_setup(run, model, equation, params, res_num)

632 633

634 - def data_init(self, name):

635 """Function for returning an initial data structure corresponding to 'name'.""" 636 637 # Empty arrays. 638 list_data = [ 'params' ] 639 if name in list_data: 640 return [] 641 642 # None. 643 none_data = [ 'equation', 644 'model', 645 's2', 646 's2f', 647 's2s', 648 'tm', 649 'te', 650 'tf', 651 'ts', 652 'rex', 653 'r', 654 'csa', 655 'chi2', 656 'iter', 657 'f_count', 658 'g_count', 659 'h_count', 660 'warning' ] 661 if name in none_data: 662 return None

663 664

665 - def data_names(self, set='all'):

666 """Function for returning a list of names of data structures. 667 668 Description 669 ~~~~~~~~~~~ 670 671 The names are as follows: 672 673 model: The model-free model name. 674 675 equation: The model-free equation type. 676 677 params: An array of the model-free parameter names associated with the model. 678 679 s2: S2. 680 681 s2f: S2f. 682 683 s2s: S2s. 684 685 tm: tm. 686 687 te: te. 688 689 tf: tf. 690 691 ts: ts. 692 693 rex: Rex. 694 695 r: Bond length. 696 697 csa: CSA value. 698 699 chi2: Chi-squared value. 700 701 iter: Iterations. 702 703 f_count: Function count. 704 705 g_count: Gradient count. 706 707 h_count: Hessian count. 708 709 warning: Minimisation warning. 710 """ 711 712 # Initialise. 713 names = [] 714 715 # Generic. 716 if set == 'all' or set == 'generic': 717 names.append('model') 718 names.append('equation') 719 names.append('params') 720 721 # Parameters. 722 if set == 'all' or set == 'params': 723 names.append('s2') 724 names.append('s2f') 725 names.append('s2s') 726 names.append('tm') 727 names.append('te') 728 names.append('tf') 729 names.append('ts') 730 names.append('rex') 731 names.append('r') 732 names.append('csa') 733 734 # Minimisation statistics. 735 if set == 'all' or set == 'min': 736 names.append('chi2') 737 names.append('iter') 738 names.append('f_count') 739 names.append('g_count') 740 names.append('h_count') 741 names.append('warning') 742 743 return names

744 745

746 - def default_value(self, param):

747 """ 748 Model-free default values 749 ~~~~~~~~~~~~~~~~~~~~~~~~~ 750 751 _______________________________________________________________________________________ 752 | | | | 753 | Data type | Object name | Value | 754 |_______________________________________|______________|______________________________| 755 | | | | 756 | Bond length | r | 1.02 * 1e-10 | 757 |_______________________________________|______________|______________________________| 758 | | | | 759 | CSA | csa | -170 * 1e-6 | 760 |_______________________________________|______________|______________________________| 761 | | | | 762 | Chemical exchange relaxation | rex | 0.0 | 763 |_______________________________________|______________|______________________________| 764 | | | | 765 | Order parameters S2, S2f, and S2s | s2, s2f, s2s | 0.8 | 766 |_______________________________________|______________|______________________________| 767 | | | | 768 | Correlation time te | te | 100 * 1e-12 | 769 |_______________________________________|______________|______________________________| 770 | | | | 771 | Correlation time tf | tf | 10 * 1e-12 | 772 |_______________________________________|______________|______________________________| 773 | | | | 774 | Correlation time ts | ts | 1000 * 1e-12 | 775 |_______________________________________|______________|______________________________| 776 | | | | 777 | Local tm | tm | 10 * 1e-9 | 778 |_______________________________________|______________|______________________________| 779 780 """ 781 782 # Bond length. 783 if param == 'r': 784 return 1.02 * 1e-10 785 786 # CSA. 787 if param == 'CSA': 788 return -170 * 1e-6 789 790 # Rex. 791 if param == 'Rex': 792 return 0.0 793 794 # {S2, S2f, S2s}. 795 if match('S2', param): 796 return 0.8 797 798 # {te, tf, ts}. 799 elif match('t', param): 800 if param == 'tf': 801 return 10.0 * 1e-12 802 elif param == 'ts': 803 return 1000.0 * 1e-12 804 elif param == 'tm': 805 return 10.0 * 1e-9 806 else: 807 return 100.0 * 1e-12

808 809

810 - def delete(self, run):

811 """Function for deleting all model-free data.""" 812 813 # Arguments. 814 self.run = run 815 816 # Test if the run exists. 817 if not self.run in self.relax.data.run_names: 818 raise RelaxNoRunError, self.run 819 820 # Test if the run type is set to 'mf'. 821 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 822 if function_type != 'mf': 823 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 824 825 # Test if the sequence data is loaded. 826 if not self.relax.data.res.has_key(self.run): 827 raise RelaxNoSequenceError, self.run 828 829 # Get all data structure names. 830 names = self.data_names() 831 832 # Loop over the sequence. 833 for i in xrange(len(self.relax.data.res[self.run])): 834 # Remap the data structure 'self.relax.data.res[self.run][i]'. 835 data = self.relax.data.res[self.run][i] 836 837 # Loop through the data structure names. 838 for name in names: 839 # Skip the data structure if it does not exist. 840 if not hasattr(data, name): 841 continue 842 843 # Delete the data. 844 delattr(data, name) 845 846 # Clean up the runs. 847 self.relax.generic.runs.eliminate_unused_runs()

848 849

850 - def determine_param_set_type(self):

851 """Determine the type of parameter set.""" 852 853 # Test if sequence data is loaded. 854 if not self.relax.data.res.has_key(self.run): 855 raise RelaxNoSequenceError, self.run 856 857 # If there is a local tm, fail if not all residues have a local tm parameter. 858 local_tm = 0 859 for i in xrange(len(self.relax.data.res[self.run])): 860 # Skip unselected residues. 861 if not self.relax.data.res[self.run][i].select: 862 continue 863 864 # No params. 865 if not hasattr(self.relax.data.res[self.run][i], 'params'): 866 continue 867 868 # Local tm. 869 if local_tm == 0 and 'tm' in self.relax.data.res[self.run][i].params: 870 local_tm = 1 871 872 # Inconsistencies. 873 elif local_tm == 1 and not 'tm' in self.relax.data.res[self.run][i].params: 874 raise RelaxError, "All residues must either have a local tm parameter or not." 875 876 # Check if any model-free parameters are allowed to vary. 877 mf_all_fixed = 1 878 for i in xrange(len(self.relax.data.res[self.run])): 879 # Skip unselected residues. 880 # This code causes a bug after model elimination if the model has been eliminated (select = 0). 881 #if not self.relax.data.res[self.run][i].select: 882 # continue 883 884 # Test the fixed flag. 885 if not hasattr(self.relax.data.res[self.run][i], 'fixed'): 886 mf_all_fixed = 0 887 break 888 if not self.relax.data.res[self.run][i].fixed: 889 mf_all_fixed = 0 890 break 891 892 # Local tm. 893 if local_tm: 894 return 'local_tm' 895 896 # Test if the diffusion tensor data is loaded. 897 if not self.relax.data.diff.has_key(self.run): 898 return None 899 900 # 'diff' parameter set. 901 if mf_all_fixed: 902 # All parameters fixed. 903 if self.relax.data.diff[self.run].fixed: 904 raise RelaxError, "All parameters are fixed." 905 906 return 'diff' 907 908 # 'mf' parameter set. 909 if self.relax.data.diff[self.run].fixed: 910 return 'mf' 911 912 # 'all' parameter set. 913 else: 914 return 'all'

915 916

917 - def disassemble_param_vector(self, index=None, sim_index=None):

918 """Function for disassembling the parameter vector.""" 919 920 # Initialise. 921 param_index = 0 922 923 # Diffusion tensor parameters of the Monte Carlo simulations. 924 if sim_index != None and (self.param_set == 'diff' or self.param_set == 'all'): 925 # Isotropic diffusion. 926 if self.relax.data.diff[self.run].type == 'iso': 927 # Sim values. 928 self.relax.data.diff[self.run].tm_sim[sim_index] = self.param_vector[0] 929 930 # Parameter index. 931 param_index = param_index + 1 932 933 # Axially symmetric diffusion. 934 elif self.relax.data.diff[self.run].type == 'axial': 935 # Minimised value of theta and phi (to wrap the angles in a window around these angles). 936 theta = self.relax.data.diff[self.run].theta 937 phi = self.relax.data.diff[self.run].phi 938 939 # Sim values. 940 self.relax.data.diff[self.run].tm_sim[sim_index] = self.param_vector[0] 941 self.relax.data.diff[self.run].Da_sim[sim_index] = self.param_vector[1] 942 self.relax.data.diff[self.run].theta_sim[sim_index] = self.relax.generic.angles.wrap_angles(self.param_vector[2], theta - pi/2.0, theta + pi/2.0) 943 self.relax.data.diff[self.run].phi_sim[sim_index] = self.relax.generic.angles.wrap_angles(self.param_vector[3], phi - pi, phi + pi) 944 945 # Parameter index. 946 param_index = param_index + 4 947 948 # Anisotropic diffusion. 949 elif self.relax.data.diff[self.run].type == 'aniso': 950 # Minimised value of alpha, beta, and gamma (to wrap the angles in a window around these angles). 951 alpha = self.relax.data.diff[self.run].alpha 952 beta = self.relax.data.diff[self.run].beta 953 gamma = self.relax.data.diff[self.run].gamma 954 955 # Sim values. 956 self.relax.data.diff[self.run].tm_sim[sim_index] = self.param_vector[0] 957 self.relax.data.diff[self.run].Da_sim[sim_index] = self.param_vector[1] 958 self.relax.data.diff[self.run].Dr_sim[sim_index] = self.param_vector[2] 959 self.relax.data.diff[self.run].alpha_sim[sim_index] = self.relax.generic.angles.wrap_angles(self.param_vector[3], alpha - pi, alpha + pi) 960 self.relax.data.diff[self.run].beta_sim[sim_index] = self.relax.generic.angles.wrap_angles(self.param_vector[4], beta - pi/2.0, beta + pi/2.0) 961 self.relax.data.diff[self.run].gamma_sim[sim_index] = self.relax.generic.angles.wrap_angles(self.param_vector[5], gamma - pi, gamma + pi) 962 963 # Parameter index. 964 param_index = param_index + 6 965 966 # Diffusion tensor parameters. 967 elif self.param_set == 'diff' or self.param_set == 'all': 968 # Isotropic diffusion. 969 if self.relax.data.diff[self.run].type == 'iso': 970 # Values. 971 self.relax.data.diff[self.run].tm = self.param_vector[0] 972 973 # Parameter index. 974 param_index = param_index + 1 975 976 # Axially symmetric diffusion. 977 elif self.relax.data.diff[self.run].type == 'axial': 978 # Values. 979 self.relax.data.diff[self.run].tm = self.param_vector[0] 980 self.relax.data.diff[self.run].Da = self.param_vector[1] 981 self.relax.data.diff[self.run].theta = self.relax.generic.angles.wrap_angles(self.param_vector[2], 0.0, pi) 982 self.relax.data.diff[self.run].phi = self.relax.generic.angles.wrap_angles(self.param_vector[3], 0.0, 2.0*pi) 983 984 # Parameter index. 985 param_index = param_index + 4 986 987 # Anisotropic diffusion. 988 elif self.relax.data.diff[self.run].type == 'aniso': 989 # Values. 990 self.relax.data.diff[self.run].tm = self.param_vector[0] 991 self.relax.data.diff[self.run].Da = self.param_vector[1] 992 self.relax.data.diff[self.run].Dr = self.param_vector[2] 993 self.relax.data.diff[self.run].alpha = self.relax.generic.angles.wrap_angles(self.param_vector[3], 0.0, 2.0*pi) 994 self.relax.data.diff[self.run].beta = self.relax.generic.angles.wrap_angles(self.param_vector[4], 0.0, pi) 995 self.relax.data.diff[self.run].gamma = self.relax.generic.angles.wrap_angles(self.param_vector[5], 0.0, 2.0*pi) 996 997 # Parameter index. 998 param_index = param_index + 6 999 1000 # Model-free parameters. 1001 if self.param_set != 'diff': 1002 # Loop over all residues. 1003 for i in xrange(len(self.relax.data.res[self.run])): 1004 # Remap the residue data structure. 1005 data = self.relax.data.res[self.run][i] 1006 1007 # Skip unselected residues. 1008 if not data.select: 1009 continue 1010 1011 # Only add parameters for a single residue if index has a value. 1012 if index != None and i != index: 1013 continue 1014 1015 # Loop over the model-free parameters. 1016 for j in xrange(len(data.params)): 1017 # tm. 1018 if data.params[j] == 'tm': 1019 if sim_index == None: 1020 data.tm = self.param_vector[param_index] 1021 else: 1022 data.tm_sim[sim_index] = self.param_vector[param_index] 1023 1024 # S2. 1025 elif data.params[j] == 'S2': 1026 if sim_index == None: 1027 data.s2 = self.param_vector[param_index] 1028 else: 1029 data.s2_sim[sim_index] = self.param_vector[param_index] 1030 1031 # S2f. 1032 elif data.params[j] == 'S2f': 1033 if sim_index == None: 1034 data.s2f = self.param_vector[param_index] 1035 else: 1036 data.s2f_sim[sim_index] = self.param_vector[param_index] 1037 1038 # S2s. 1039 elif data.params[j] == 'S2s': 1040 if sim_index == None: 1041 data.s2s = self.param_vector[param_index] 1042 else: 1043 data.s2s_sim[sim_index] = self.param_vector[param_index] 1044 1045 # te. 1046 elif data.params[j] == 'te': 1047 if sim_index == None: 1048 data.te = self.param_vector[param_index] 1049 else: 1050 data.te_sim[sim_index] = self.param_vector[param_index] 1051 1052 # tf. 1053 elif data.params[j] == 'tf': 1054 if sim_index == None: 1055 data.tf = self.param_vector[param_index] 1056 else: 1057 data.tf_sim[sim_index] = self.param_vector[param_index] 1058 1059 # ts. 1060 elif data.params[j] == 'ts': 1061 if sim_index == None: 1062 data.ts = self.param_vector[param_index] 1063 else: 1064 data.ts_sim[sim_index] = self.param_vector[param_index] 1065 1066 # Rex. 1067 elif data.params[j] == 'Rex': 1068 if sim_index == None: 1069 data.rex = self.param_vector[param_index] 1070 else: 1071 data.rex_sim[sim_index] = self.param_vector[param_index] 1072 1073 # r. 1074 elif data.params[j] == 'r': 1075 if sim_index == None: 1076 data.r = self.param_vector[param_index] 1077 else: 1078 data.r_sim[sim_index] = self.param_vector[param_index] 1079 1080 # CSA. 1081 elif data.params[j] == 'CSA': 1082 if sim_index == None: 1083 data.csa = self.param_vector[param_index] 1084 else: 1085 data.csa_sim[sim_index] = self.param_vector[param_index] 1086 1087 # Unknown parameter. 1088 else: 1089 raise RelaxError, "Unknown parameter." 1090 1091 # Increment the parameter index. 1092 param_index = param_index + 1 1093 1094 # Calculate all order parameters after unpacking the vector. 1095 if self.param_set != 'diff': 1096 # Loop over all residues. 1097 for i in xrange(len(self.relax.data.res[self.run])): 1098 # Remap the residue data structure. 1099 data = self.relax.data.res[self.run][i] 1100 1101 # Skip unselected residues. 1102 if not data.select: 1103 continue 1104 1105 # Only add parameters for a single residue if index has a value. 1106 if index != None and i != index: 1107 continue 1108 1109 # Normal values. 1110 if sim_index == None: 1111 # S2. 1112 if 'S2' not in data.params and 'S2f' in data.params and 'S2s' in data.params: 1113 data.s2 = data.s2f * data.s2s 1114 1115 # S2f. 1116 if 'S2f' not in data.params and 'S2' in data.params and 'S2s' in data.params: 1117 if data.s2s == 0.0: 1118 data.s2f = 1e99 1119 else: 1120 data.s2f = data.s2 / data.s2s 1121 1122 # S2s. 1123 if 'S2s' not in data.params and 'S2' in data.params and 'S2f' in data.params: 1124 if data.s2f == 0.0: 1125 data.s2s = 1e99 1126 else: 1127 data.s2s = data.s2 / data.s2f 1128 1129 # Simulation values. 1130 else: 1131 # S2. 1132 if 'S2' not in data.params and 'S2f' in data.params and 'S2s' in data.params: 1133 data.s2_sim[sim_index] = data.s2f_sim[sim_index] * data.s2s_sim[sim_index] 1134 1135 # S2f. 1136 if 'S2f' not in data.params and 'S2' in data.params and 'S2s' in data.params: 1137 if data.s2s_sim[sim_index] == 0.0: 1138 data.s2f_sim[sim_index] = 1e99 1139 else: 1140 data.s2f_sim[sim_index] = data.s2_sim[sim_index] / data.s2s_sim[sim_index] 1141 1142 # S2s. 1143 if 'S2s' not in data.params and 'S2' in data.params and 'S2f' in data.params: 1144 if data.s2f_sim[sim_index] == 0.0: 1145 data.s2s_sim[sim_index] = 1e99 1146 else: 1147 data.s2s_sim[sim_index] = data.s2_sim[sim_index] / data.s2f_sim[sim_index]

1148 1149

1150 - def duplicate_data(self, new_run=None, old_run=None, instance=None):

1151 """Function for duplicating data.""" 1152 1153 # self.run for determining the parameter set. 1154 self.run = old_run 1155 1156 # Duplicate all non-residue specific data. 1157 for data_name in dir(self.relax.data): 1158 # Skip 'res'. 1159 if data_name == 'res': 1160 continue 1161 1162 # Get the object. 1163 data = getattr(self.relax.data, data_name) 1164 1165 # Skip the data if it is not a dictionary (or equivalent). 1166 if not hasattr(data, 'has_key'): 1167 continue 1168 1169 # Skip the data if it doesn't contain the key 'old_run'. 1170 if not data.has_key(old_run): 1171 continue 1172 1173 # If the dictionary already contains the key 'new_run', but the data is different, raise an error (skip PDB and diffusion data). 1174 if data_name != 'pdb' and data_name != 'diff' and data.has_key(new_run) and data[old_run] != data[new_run]: 1175 raise RelaxError, "The data between run " + `new_run` + " and run " + `old_run` + " is not consistent." 1176 1177 # Skip the data if it contains the key 'new_run'. 1178 if data.has_key(new_run): 1179 continue 1180 1181 # Duplicate the data. 1182 data[new_run] = deepcopy(data[old_run]) 1183 1184 # Determine the parameter set type. 1185 self.param_set = self.determine_param_set_type() 1186 1187 # Sequence specific data. 1188 if self.param_set == 'mf' or self.param_set == 'local_tm': 1189 # Create the sequence data if it does not exist. 1190 if not self.relax.data.res.has_key(new_run) or not len(self.relax.data.res[new_run]): 1191 # Add the new run to 'self.relax.data.res'. 1192 self.relax.data.res.add_list(new_run) 1193 1194 # Fill the array 'self.relax.data.res[new_run]' with empty data containers and place sequence data into the array. 1195 for i in xrange(len(self.relax.data.res[old_run])): 1196 # Append a data container. 1197 self.relax.data.res[new_run].add_item() 1198 1199 # Insert the data. 1200 self.relax.data.res[new_run][i].num = self.relax.data.res[old_run][i].num 1201 self.relax.data.res[new_run][i].name = self.relax.data.res[old_run][i].name 1202 self.relax.data.res[new_run][i].select = self.relax.data.res[old_run][i].select 1203 1204 # Duplicate the residue specific data. 1205 self.relax.data.res[new_run][instance] = deepcopy(self.relax.data.res[old_run][instance]) 1206 1207 # Other data types. 1208 elif self.param_set == 'diff' or self.param_set == 'all': 1209 # Duplicate the residue specific data. 1210 self.relax.data.res[new_run] = deepcopy(self.relax.data.res[old_run])

1211 1212

1213 - def eliminate(self, name, value, run, i, args):

1214 """ 1215 Model-free model elimination rules 1216 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1217 1218 Local tm. 1219 1220 The local tm, in some cases, may exceed the value expected for a global correlation time. 1221 Generally the tm value will be stuck at the upper limit defined for the parameter. These 1222 models are eliminated using the rule: 1223 1224 tm >= c 1225 1226 The default value of c is 50 ns, although this can be overriden by supplying the value (in 1227 seconds) as the first element of the args tuple. 1228 1229 1230 Internal correlation times {te, tf, ts}. 1231 1232 These parameters may experience the same problem as the local tm in that the model fails and 1233 the parameter value is stuck at the upper limit. These parameters are constrained using the 1234 formula 'te, tf, ts <= 2.tm'. These failed models are eliminated using the rule: 1235 1236 te, tf, ts >= c.tm 1237 1238 The default value of c is 1.5. Because of round-off errors and the constraint algorithm, 1239 setting c to 2 will result in no models being eliminated as the minimised parameters will 1240 always be less than 2.tm. The value can be changed by supplying the value as the second 1241 element of the tuple. 1242 1243 1244 Arguments. 1245 1246 The 'args' argument must be a tuple of length 2, the elements of which must be numbers. For 1247 example, to eliminate models which have a local tm value greater than 25 ns and models with 1248 internal correlation times greater than 1.5 times tm, set 'args' to (25 * 1e-9, 1.5). 1249 """ 1250 1251 # Default values. 1252 c1 = 50.0 * 1e-9 1253 c2 = 1.5 1254 1255 # Depack the arguments. 1256 if args != None: 1257 c1, c2 = args 1258 1259 # Get the tm value. 1260 if self.param_set == 'local_tm': 1261 tm = self.relax.data.res[run][i].tm 1262 else: 1263 tm = self.relax.data.diff[run].tm 1264 1265 # Local tm. 1266 if name == 'tm' and value >= c1: 1267 return 1 1268 1269 # Internal correlation times. 1270 if match('t[efs]', name) and value >= c2 * tm: 1271 return 1 1272 1273 # Accept model. 1274 return 0

1275 1276

1277 - def get_data_name(self, name):

1278 """ 1279 Model-free data type string matching patterns 1280 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1281 1282 ____________________________________________________________________________________________ 1283 | | | | 1284 | Data type | Object name | Patterns | 1285 |________________________|______________|__________________________________________________| 1286 | | | | 1287 | Bond length | r | '^r$' or '[Bb]ond[ -_][Ll]ength' | 1288 |________________________|______________|__________________________________________________| 1289 | | | | 1290 | CSA | csa | '^[Cc][Ss][Aa]$' | 1291 |________________________|______________|__________________________________________________| 1292 | | | | 1293 | Chemical exchange | rex | '^[Rr]ex$' or '[Cc]emical[ -_][Ee]xchange' | 1294 |________________________|______________|__________________________________________________| 1295 | | | | 1296 | Order parameter S2 | s2 | '^[Ss]2$' | 1297 |________________________|______________|__________________________________________________| 1298 | | | | 1299 | Order parameter S2f | s2f | '^[Ss]2f$' | 1300 |________________________|______________|__________________________________________________| 1301 | | | | 1302 | Order parameter S2s | s2s | '^[Ss]2s$' | 1303 |________________________|______________|__________________________________________________| 1304 | | | | 1305 | Correlation time te | te | '^te$' | 1306 |________________________|______________|__________________________________________________| 1307 | | | | 1308 | Correlation time tf | tf | '^tf$' | 1309 |________________________|______________|__________________________________________________| 1310 | | | | 1311 | Correlation time ts | ts | '^ts$' | 1312 |________________________|______________|__________________________________________________| 1313 | | | | 1314 | Local tm | tm | '^tm$' | 1315 |________________________|______________|__________________________________________________| 1316 1317 """ 1318 1319 # Bond length. 1320 if match('^r$', name) or match('[Bb]ond[ -_][Ll]ength', name): 1321 return 'r' 1322 1323 # CSA. 1324 if match('^[Cc][Ss][Aa]$', name): 1325 return 'csa' 1326 1327 # Rex 1328 if match('^[Rr]ex$', name) or match('[Cc]emical[ -_][Ee]xchange', name): 1329 return 'rex' 1330 1331 # Order parameter S2. 1332 if match('^[Ss]2$', name): 1333 return 's2' 1334 1335 # Order parameter S2f. 1336 if match('^[Ss]2f$', name): 1337 return 's2f' 1338 1339 # Order parameter S2s. 1340 if match('^[Ss]2s$', name): 1341 return 's2s' 1342 1343 # Correlation time te. 1344 if match('^te$', name): 1345 return 'te' 1346 1347 # Correlation time tf. 1348 if match('^tf$', name): 1349 return 'tf' 1350 1351 # Correlation time ts. 1352 if match('^ts$', name): 1353 return 'ts' 1354 1355 # Local tm. 1356 if match('^tm$', name): 1357 return 'tm'

1358 1359

1360 - def get_param_names(self, run, i):

1361 """Function for returning a vector of parameter names.""" 1362 1363 # Arguments 1364 self.run = run 1365 1366 # Skip residues where there is no data or errors. 1367 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not hasattr(self.relax.data.res[self.run][i], 'relax_error'): 1368 return 1369 1370 # Test if the model-free model has been setup. 1371 for j in xrange(len(self.relax.data.res[self.run])): 1372 # Skip unselected residues. 1373 if not self.relax.data.res[self.run][j].select: 1374 continue 1375 1376 # Not setup. 1377 if not self.relax.data.res[self.run][j].model: 1378 raise RelaxNoMfModelError, self.run 1379 1380 # Determine the parameter set type. 1381 self.param_set = self.determine_param_set_type() 1382 1383 # Residue index. 1384 if self.param_set == 'mf' or self.param_set == 'local_tm': 1385 index = i 1386 else: 1387 index = None 1388 1389 # Assemble the parameter names. 1390 self.assemble_param_names(index=index) 1391 1392 # Return the parameter names. 1393 return self.param_names

1394 1395

1396 - def get_param_values(self, run, i):

1397 """Function for returning a vector of parameter values.""" 1398 1399 # Arguments 1400 self.run = run 1401 1402 # Skip residues where there is no data or errors. 1403 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not hasattr(self.relax.data.res[self.run][i], 'relax_error'): 1404 return 1405 1406 # Test if the model-free model has been setup. 1407 for j in xrange(len(self.relax.data.res[self.run])): 1408 # Skip unselected residues. 1409 if not self.relax.data.res[self.run][j].select: 1410 continue 1411 1412 # Not setup. 1413 if not self.relax.data.res[self.run][j].model: 1414 raise RelaxNoMfModelError, self.run 1415 1416 # Determine the parameter set type. 1417 self.param_set = self.determine_param_set_type() 1418 1419 # Residue index. 1420 if self.param_set == 'mf' or self.param_set == 'local_tm': 1421 index = i 1422 else: 1423 index = None 1424 1425 # Assemble the parameter values. 1426 self.param_vector = self.assemble_param_vector(index=index) 1427 1428 # Return the parameter names. 1429 return self.param_vector

1430 1431

1432 - def grid_search(self, run, lower, upper, inc, constraints, print_flag, sim_index=None):

1433 """The grid search function.""" 1434 1435 # Arguments. 1436 self.lower = lower 1437 self.upper = upper 1438 self.inc = inc 1439 1440 # Minimisation. 1441 self.minimise(run=run, min_algor='grid', constraints=constraints, print_flag=print_flag, sim_index=sim_index)

1442 1443

1444 - def grid_search_setup(self, index=None):

1445 """The grid search setup function.""" 1446 1447 # The length of the parameter array. 1448 n = len(self.param_vector) 1449 1450 # Make sure that the length of the parameter array is > 0. 1451 if n == 0: 1452 raise RelaxError, "Cannot run a grid search on a model with zero parameters." 1453 1454 # Lower bounds. 1455 if self.lower != None: 1456 if len(self.lower) != n: 1457 raise RelaxLenError, ('lower bounds', n) 1458 1459 # Upper bounds. 1460 if self.upper != None: 1461 if len(self.upper) != n: 1462 raise RelaxLenError, ('upper bounds', n) 1463 1464 # Increment. 1465 if type(self.inc) == list: 1466 if len(self.inc) != n: 1467 raise RelaxLenError, ('increment', n) 1468 inc = self.inc 1469 elif type(self.inc) == int: 1470 temp = [] 1471 for j in xrange(n): 1472 temp.append(self.inc) 1473 inc = temp 1474 1475 # Minimisation options initialisation. 1476 min_options = [] 1477 m = 0 1478 1479 # Minimisation options for diffusion tensor parameters. 1480 if self.param_set == 'diff' or self.param_set == 'all': 1481 # Isotropic diffusion {tm}. 1482 if self.relax.data.diff[self.run].type == 'iso': 1483 min_options.append([inc[0], 1.0 * 1e-9, 20.0 * 1e-9]) 1484 m = m + 1 1485 1486 # Axially symmetric diffusion {tm, Da, theta, phi}. 1487 if self.relax.data.diff[self.run].type == 'axial': 1488 min_options.append([inc[0], 1.0 * 1e-9, 20.0 * 1e-9]) 1489 if self.relax.data.diff[self.run].axial_type == 'prolate': 1490 min_options.append([inc[1], 0.0, 1e7]) 1491 elif self.relax.data.diff[self.run].axial_type == 'oblate': 1492 min_options.append([inc[1], -1e7, 0.0]) 1493 else: 1494 min_options.append([inc[1], -1e7, 1e7]) 1495 min_options.append([inc[2], 0.0, pi]) 1496 min_options.append([inc[3], 0.0, 2 * pi]) 1497 m = m + 4 1498 1499 # Anisotropic diffusion {tm, Da, Dr, alpha, beta, gamma}. 1500 elif self.relax.data.diff[self.run].type == 'aniso': 1501 min_options.append([inc[0], 1.0 * 1e-9, 20.0 * 1e-9]) 1502 min_options.append([inc[1], -1e7, 1e7]) 1503 min_options.append([inc[2], -1e7, 1e7]) 1504 min_options.append([inc[3], 0.0, 2 * pi]) 1505 min_options.append([inc[4], 0.0, pi]) 1506 min_options.append([inc[5], 0.0, 2 * pi]) 1507 m = m + 6 1508 1509 # Model-free parameters (residue specific parameters). 1510 if self.param_set != 'diff': 1511 for i in xrange(len(self.relax.data.res[self.run])): 1512 # Skip unselected residues. 1513 if not self.relax.data.res[self.run][i].select: 1514 continue 1515 1516 # Only add parameters for a single residue if index has a value. 1517 if index != None and i != index: 1518 continue 1519 1520 # Loop over the model-free parameters. 1521 for j in xrange(len(self.relax.data.res[self.run][i].params)): 1522 # Local tm. 1523 if self.relax.data.res[self.run][i].params[j] == 'tm': 1524 min_options.append([inc[m], 1.0 * 1e-9, 20.0 * 1e-9]) 1525 1526 # {S2, S2f, S2s}. 1527 elif match('S2', self.relax.data.res[self.run][i].params[j]): 1528 min_options.append([inc[m], 0.0, 1.0]) 1529 1530 # {te, tf, ts}. 1531 elif match('t', self.relax.data.res[self.run][i].params[j]): 1532 min_options.append([inc[m], 0.0, 500.0 * 1e-12]) 1533 1534 # Rex. 1535 elif self.relax.data.res[self.run][i].params[j] == 'Rex': 1536 min_options.append([inc[m], 0.0, 5.0 / (2.0 * pi * self.relax.data.res[self.run][i].frq[0])**2]) 1537 1538 # Bond length. 1539 elif self.relax.data.res[self.run][i].params[j] == 'r': 1540 min_options.append([inc[m], 1.0 * 1e-10, 1.05 * 1e-10]) 1541 1542 # CSA. 1543 elif self.relax.data.res[self.run][i].params[j] == 'CSA': 1544 min_options.append([inc[m], -120 * 1e-6, -200 * 1e-6]) 1545 1546 # Unknown option. 1547 else: 1548 raise RelaxError, "Unknown model-free parameter." 1549 1550 # Increment m. 1551 m = m + 1 1552 1553 # Set the lower and upper bounds if these are supplied. 1554 if self.lower != None: 1555 for j in xrange(n): 1556 if self.lower[j] != None: 1557 min_options[j][1] = self.lower[j] 1558 if self.upper != None: 1559 for j in xrange(n): 1560 if self.upper[j] != None: 1561 min_options[j][2] = self.upper[j] 1562 1563 # Test if the grid is too large. 1564 self.grid_size = 1 1565 for i in xrange(len(min_options)): 1566 self.grid_size = self.grid_size * min_options[i][0] 1567 if type(self.grid_size) == long: 1568 raise RelaxError, "A grid search of size " + `self.grid_size` + " is too large." 1569 1570 # Diagonal scaling of minimisation options. 1571 for j in xrange(len(min_options)): 1572 min_options[j][1] = min_options[j][1] / self.scaling_matrix[j, j] 1573 min_options[j][2] = min_options[j][2] / self.scaling_matrix[j, j] 1574 1575 return min_options

1576 1577

1578 - def linear_constraints(self, index=None):

1579 """Function for setting up the model-free linear constraint matrices A and b. 1580 1581 Standard notation 1582 ~~~~~~~~~~~~~~~~~ 1583 1584 The order parameter constraints are: 1585 1586 0 <= S2 <= 1 1587 0 <= S2f <= 1 1588 0 <= S2s <= 1 1589 1590 By substituting the formula S2 = S2f.S2s into the above inequalities, the additional two 1591 inequalities can be derived: 1592 1593 S2 <= S2f 1594 S2 <= S2s 1595 1596 Correlation time constraints are: 1597 1598 te >= 0 1599 tf >= 0 1600 ts >= 0 1601 1602 tf <= ts 1603 1604 te, tf, ts <= 2 * tm 1605 1606 Additional constraints used include: 1607 1608 Rex >= 0 1609 0.9e-10 <= r <= 2e-10 1610 -300e-6 <= CSA <= 0 1611 1612 1613 Rearranged notation 1614 ~~~~~~~~~~~~~~~~~~~ 1615 The above ineqality constraints can be rearranged into: 1616 1617 S2 >= 0 1618 -S2 >= -1 1619 S2f >= 0 1620 -S2f >= -1 1621 S2s >= 0 1622 -S2s >= -1 1623 S2f - S2 >= 0 1624 S2s - S2 >= 0 1625 te >= 0 1626 tf >= 0 1627 ts >= 0 1628 ts - tf >= 0 1629 Rex >= 0 1630 r >= 0.9e-10 1631 -r >= -2e-10 1632 CSA >= -300e-6 1633 -CSA >= 0 1634 1635 1636 Matrix notation 1637 ~~~~~~~~~~~~~~~ 1638 1639 In the notation A.x >= b, where A is an matrix of coefficients, x is an array of parameter 1640 values, and b is a vector of scalars, these inequality constraints are: 1641 1642 | 1 0 0 0 0 0 0 0 0 | | 0 | 1643 | | | | 1644 |-1 0 0 0 0 0 0 0 0 | | -1 | 1645 | | | | 1646 | 0 1 0 0 0 0 0 0 0 | | 0 | 1647 | | | | 1648 | 0 -1 0 0 0 0 0 0 0 | | -1 | 1649 | | | | 1650 | 0 0 1 0 0 0 0 0 0 | | S2 | | 0 | 1651 | | | | | | 1652 | 0 0 -1 0 0 0 0 0 0 | | S2f | | -1 | 1653 | | | | | | 1654 |-1 1 0 0 0 0 0 0 0 | | S2s | | 0 | 1655 | | | | | | 1656 |-1 0 1 0 0 0 0 0 0 | | te | | 0 | 1657 | | | | | | 1658 | 0 0 0 1 0 0 0 0 0 | . | tf | >= | 0 | 1659 | | | | | | 1660 | 0 0 0 0 1 0 0 0 0 | | ts | | 0 | 1661 | | | | | | 1662 | 0 0 0 0 0 1 0 0 0 | | Rex | | 0 | 1663 | | | | | | 1664 | 0 0 0 0 -1 1 0 0 0 | | r | | 0 | 1665 | | | | | | 1666 | 0 0 0 0 0 0 1 0 0 | | CSA | | 0 | 1667 | | | | 1668 | 0 0 0 0 0 0 0 1 0 | | 0.9e-10 | 1669 | | | | 1670 | 0 0 0 0 0 0 0 -1 0 | | -2e-10 | 1671 | | | | 1672 | 0 0 0 0 0 0 0 0 1 | | -300e-6 | 1673 | | | | 1674 | 0 0 0 0 0 0 0 0 -1 | | 0 | 1675 1676 """ 1677 1678 # Upper limit flag for correlation times. 1679 upper_time_limit = 1 1680 1681 # Initialisation (0..j..m). 1682 A = [] 1683 b = [] 1684 n = len(self.param_vector) 1685 zero_array = zeros(n, Float64) 1686 i = 0 1687 j = 0 1688 1689 # Diffusion tensor parameters. 1690 if self.param_set != 'mf' and self.relax.data.diff.has_key(self.run): 1691 # Isotropic diffusion. 1692 if self.relax.data.diff[self.run].type == 'iso': 1693 # 0 <= tm <= 200 ns. 1694 A.append(zero_array * 0.0) 1695 A.append(zero_array * 0.0) 1696 A[j][i] = 1.0 1697 A[j+1][i] = -1.0 1698 b.append(0.0 / self.scaling_matrix[i, i]) 1699 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i]) 1700 i = i + 1 1701 j = j + 2 1702 1703 # Axially symmetric diffusion. 1704 elif self.relax.data.diff[self.run].type == 'axial': 1705 # 0 <= tm <= 200 ns. 1706 A.append(zero_array * 0.0) 1707 A.append(zero_array * 0.0) 1708 A[j][i] = 1.0 1709 A[j+1][i] = -1.0 1710 b.append(0.0 / self.scaling_matrix[i, i]) 1711 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i]) 1712 i = i + 1 1713 j = j + 2 1714 1715 # Prolate diffusion, Da >= 0. 1716 if self.relax.data.diff[self.run].axial_type == 'prolate': 1717 A.append(zero_array * 0.0) 1718 A[j][i] = 1.0 1719 b.append(0.0 / self.scaling_matrix[i, i]) 1720 i = i + 1 1721 j = j + 1 1722 1723 # Add two to i for the theta and phi parameters. 1724 i = i + 2 1725 1726 # Oblate diffusion, Da <= 0. 1727 elif self.relax.data.diff[self.run].axial_type == 'oblate': 1728 A.append(zero_array * 0.0) 1729 A[j][i] = -1.0 1730 b.append(0.0 / self.scaling_matrix[i, i]) 1731 i = i + 1 1732 j = j + 1 1733 1734 # Add two to i for the theta and phi parameters. 1735 i = i + 2 1736 1737 else: 1738 # Add three to i for the Da, theta and phi parameters. 1739 i = i + 3 1740 1741 # Anisotropic diffusion. 1742 elif self.relax.data.diff[self.run].type == 'aniso': 1743 # 0 <= tm <= 200 ns. 1744 A.append(zero_array * 0.0) 1745 A.append(zero_array * 0.0) 1746 A[j][i] = 1.0 1747 A[j+1][i] = -1.0 1748 b.append(0.0 / self.scaling_matrix[i, i]) 1749 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i]) 1750 i = i + 1 1751 j = j + 2 1752 1753 # Add five to i for the Da, Dr, alpha, beta, and gamma parameters. 1754 i = i + 5 1755 1756 # Model-free parameters. 1757 if self.param_set != 'diff': 1758 # Loop over all residues. 1759 for k in xrange(len(self.relax.data.res[self.run])): 1760 # Skip unselected residues. 1761 if not self.relax.data.res[self.run][k].select: 1762 continue 1763 1764 # Only add parameters for a single residue if index has a value. 1765 if index != None and k != index: 1766 continue 1767 1768 # Save current value of i. 1769 old_i = i 1770 1771 # Loop over the model-free parameters. 1772 for l in xrange(len(self.relax.data.res[self.run][k].params)): 1773 # Local tm. 1774 if self.relax.data.res[self.run][k].params[l] == 'tm': 1775 if upper_time_limit: 1776 # 0 <= tm <= 200 ns. 1777 A.append(zero_array * 0.0) 1778 A.append(zero_array * 0.0) 1779 A[j][i] = 1.0 1780 A[j+1][i] = -1.0 1781 b.append(0.0 / self.scaling_matrix[i, i]) 1782 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i]) 1783 j = j + 2 1784 else: 1785 # 0 <= tm. 1786 A.append(zero_array * 0.0) 1787 A[j][i] = 1.0 1788 b.append(0.0 / self.scaling_matrix[i, i]) 1789 j = j + 1 1790 1791 # Order parameters {S2, S2f, S2s}. 1792 elif match('S2', self.relax.data.res[self.run][k].params[l]): 1793 # 0 <= S2 <= 1. 1794 A.append(zero_array * 0.0) 1795 A.append(zero_array * 0.0) 1796 A[j][i] = 1.0 1797 A[j+1][i] = -1.0 1798 b.append(0.0 / self.scaling_matrix[i, i]) 1799 b.append(-1.0 / self.scaling_matrix[i, i]) 1800 j = j + 2 1801 1802 # S2 <= S2f and S2 <= S2s. 1803 if self.relax.data.res[self.run][k].params[l] == 'S2': 1804 for m in xrange(len(self.relax.data.res[self.run][k].params)): 1805 if self.relax.data.res[self.run][k].params[m] == 'S2f' or self.relax.data.res[self.run][k].params[m] == 'S2s': 1806 A.append(zero_array * 0.0) 1807 A[j][i] = -1.0 1808 A[j][old_i+m] = 1.0 1809 b.append(0.0) 1810 j = j + 1 1811 1812 # Correlation times {te, tf, ts}. 1813 elif match('t[efs]', self.relax.data.res[self.run][k].params[l]): 1814 # te, tf, ts >= 0. 1815 A.append(zero_array * 0.0) 1816 A[j][i] = 1.0 1817 b.append(0.0 / self.scaling_matrix[i, i]) 1818 j = j + 1 1819 1820 # tf <= ts. 1821 if self.relax.data.res[self.run][k].params[l] == 'ts': 1822 for m in xrange(len(self.relax.data.res[self.run][k].params)): 1823 if self.relax.data.res[self.run][k].params[m] == 'tf': 1824 A.append(zero_array * 0.0) 1825 A[j][i] = 1.0 1826 A[j][old_i+m] = -1.0 1827 b.append(0.0) 1828 j = j + 1 1829 1830 # te, tf, ts <= 2 * tm. (tf not needed because tf <= ts). 1831 if upper_time_limit: 1832 if not self.relax.data.res[self.run][k].params[l] == 'tf': 1833 if self.param_set == 'mf': 1834 A.append(zero_array * 0.0) 1835 A[j][i] = -1.0 1836 b.append(-2.0 * self.relax.data.diff[self.run].tm / self.scaling_matrix[i, i]) 1837 else: 1838 A.append(zero_array * 0.0) 1839 A[j][0] = 2.0 1840 A[j][i] = -1.0 1841 b.append(0.0) 1842 1843 j = j + 1 1844 1845 # Rex. 1846 elif self.relax.data.res[self.run][k].params[l] == 'Rex': 1847 A.append(zero_array * 0.0) 1848 A[j][i] = 1.0 1849 b.append(0.0 / self.scaling_matrix[i, i]) 1850 j = j + 1 1851 1852 # Bond length. 1853 elif self.relax.data.res[self.run][k].params[l] == 'r': 1854 # 0.9e-10 <= r <= 2e-10. 1855 A.append(zero_array * 0.0) 1856 A.append(zero_array * 0.0) 1857 A[j][i] = 1.0 1858 A[j+1][i] = -1.0 1859 b.append(0.9e-10 / self.scaling_matrix[i, i]) 1860 b.append(-2e-10 / self.scaling_matrix[i, i]) 1861 j = j + 2 1862 1863 # CSA. 1864 elif self.relax.data.res[self.run][k].params[l] == 'CSA': 1865 # -300e-6 <= CSA <= 0. 1866 A.append(zero_array * 0.0) 1867 A.append(zero_array * 0.0) 1868 A[j][i] = 1.0 1869 A[j+1][i] = -1.0 1870 b.append(-300e-6 / self.scaling_matrix[i, i]) 1871 b.append(0.0 / self.scaling_matrix[i, i]) 1872 j = j + 2 1873 1874 # Increment i. 1875 i = i + 1 1876 1877 # Convert to Numeric data structures. 1878 A = array(A, Float64) 1879 b = array(b, Float64) 1880 1881 return A, b

1882 1883

1884 - def map_bounds(self, run, index):

1885 """The function for creating bounds for the mapping function.""" 1886 1887 # Arguments. 1888 self.run = run 1889 1890 # Determine the parameter set type. 1891 #self.param_set = self.determine_param_set_type() 1892 1893 # Parameter array. 1894 params = self.relax.data.res[run][index].params 1895 1896 # Bounds array. 1897 bounds = zeros((len(params), 2), Float64) 1898 1899 # Loop over the parameters. 1900 for i in xrange(len(params)): 1901 # {S2, S2f, S2s}. 1902 if match('S2', params[i]): 1903 bounds[i] = [0, 1] 1904 1905 # {tm, te, tf, ts}. 1906 elif match('t', params[i]): 1907 bounds[i] = [0, 1e-8] 1908 1909 # Rex. 1910 elif params[i] == 'Rex': 1911 bounds[i] = [0, 30.0 / (2.0 * pi * self.relax.data.res[run][index].frq[0])**2] 1912 1913 # Bond length. 1914 elif params[i] == 'r': 1915 bounds[i] = [1.0 * 1e-10, 1.1 * 1e-10] 1916 1917 # CSA. 1918 elif params[i] == 'CSA': 1919 bounds[i] = [-100 * 1e-6, -300 * 1e-6] 1920 1921 return bounds

1922 1923

1924 - def map_labels(self, run, index, params, bounds, swap, inc):

1925 """Function for creating labels, tick locations, and tick values for an OpenDX map.""" 1926 1927 # Initialise. 1928 labels = "{" 1929 tick_locations = [] 1930 tick_values = [] 1931 n = len(params) 1932 axis_incs = 5 1933 loc_inc = inc / axis_incs 1934 1935 # Increment over the model parameters. 1936 for i in xrange(n): 1937 # Local tm. 1938 if params[swap[i]] == 'tm': 1939 # Labels. 1940 labels = labels + "\"" + params[swap[i]] + " (ns)\"" 1941 1942 # Tick values. 1943 vals = bounds[swap[i], 0] * 1e9 1944 val_inc = (bounds[swap[i], 1] - bounds[swap[i], 0]) / axis_incs * 1e9 1945 1946 # {S2, S2f, S2s}. 1947 elif match('S2', params[swap[i]]): 1948 # Labels. 1949 labels = labels + "\"" + params[swap[i]] + "\"" 1950 1951 # Tick values. 1952 vals = bounds[swap[i], 0] * 1.0 1953 val_inc = (bounds[swap[i], 1] - bounds[swap[i], 0]) / axis_incs * 1.0 1954 1955 # {te, tf, and ts}. 1956 elif match('t', params[swap[i]]): 1957 # Labels. 1958 labels = labels + "\"" + params[swap[i]] + " (ps)\"" 1959 1960 # Tick values. 1961 vals = bounds[swap[i], 0] * 1e12 1962 val_inc = (bounds[swap[i], 1] - bounds[swap[i], 0]) / axis_incs * 1e12 1963 1964 # Rex. 1965 elif params[swap[i]] == 'Rex': 1966 # Labels. 1967 labels = labels + "\"Rex (" + self.relax.data.res[run][index].frq_labels[0] + " MHz)\"" 1968 1969 # Tick values. 1970 vals = bounds[swap[i], 0] * (2.0 * pi * self.relax.data.res[run][index].frq[0])**2 1971 val_inc = (bounds[swap[i], 1] - bounds[swap[i], 0]) / axis_incs * (2.0 * pi * self.relax.data.res[run][index].frq[0])**2 1972 1973 # Bond length. 1974 elif params[swap[i]] == 'r': 1975 # Labels. 1976 labels = labels + "\"" + params[swap[i]] + " (A)\"" 1977 1978 # Tick values. 1979 vals = bounds[swap[i], 0] * 1e-10 1980 val_inc = (bounds[swap[i], 1] - bounds[swap[i], 0]) / axis_incs * 1e-10 1981 1982 # CSA. 1983 elif params[swap[i]] == 'CSA': 1984 # Labels. 1985 labels = labels + "\"" + params[swap[i]] + " (ppm)\"" 1986 1987 # Tick values. 1988 vals = bounds[swap[i], 0] * 1e-6 1989 val_inc = (bounds[swap[i], 1] - bounds[swap[i], 0]) / axis_incs * 1e-6 1990 1991 if i < n - 1: 1992 labels = labels + " " 1993 else: 1994 labels = labels + "}" 1995 1996 # Tick locations. 1997 string = "{" 1998 val = 0.0 1999 for j in xrange(axis_incs + 1): 2000 string = string + " " + `val` 2001 val = val + loc_inc 2002 string = string + " }" 2003 tick_locations.append(string) 2004 2005 # Tick values. 2006 string = "{" 2007 for j in xrange(axis_incs + 1): 2008 string = string + "\"" + "%.2f" % vals + "\" " 2009 vals = vals + val_inc 2010 string = string + "}" 2011 tick_values.append(string) 2012 2013 return labels, tick_locations, tick_values

2014 2015

2016 - def minimise(self, run=None, min_algor=None, min_options=None, func_tol=None, grad_tol=None, max_iterations=None, constraints=0, scaling=1, print_flag=0, sim_index=None):

2017 """Model-free minimisation. 2018 2019 Three types of parameter sets exist for which minimisation is different. These are: 2020 'mf' - Model-free parameters for single residues. 2021 'diff' - Diffusion tensor parameters. 2022 'all' - All model-free and all diffusion tensor parameters. 2023 2024 """ 2025 2026 # Arguments. 2027 self.run = run 2028 self.print_flag = print_flag 2029 2030 # Test if the model-free model has been setup. 2031 for i in xrange(len(self.relax.data.res[self.run])): 2032 # Skip unselected residues. 2033 if not self.relax.data.res[self.run][i].select: 2034 continue 2035 2036 # Not setup. 2037 if not self.relax.data.res[self.run][i].model: 2038 raise RelaxNoMfModelError, self.run 2039 2040 # Determine the parameter set type. 2041 self.param_set = self.determine_param_set_type() 2042 2043 # Parameter set for the back-calculate function. 2044 if min_algor == 'back_calc' and self.param_set != 'local_tm': 2045 self.param_set = 'mf' 2046 2047 # Test if diffusion tensor data for the run exists. 2048 if self.param_set != 'local_tm' and not self.relax.data.diff.has_key(self.run): 2049 raise RelaxNoTensorError, self.run 2050 2051 # Tests for the PDB file and unit vectors. 2052 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'iso': 2053 # Test if the PDB file has been loaded. 2054 if not self.relax.data.pdb.has_key(self.run): 2055 raise RelaxNoPdbError, self.run 2056 2057 # Test if unit vectors exist. 2058 for i in xrange(len(self.relax.data.res[self.run])): 2059 # Skip unselected residues. 2060 if not self.relax.data.res[self.run][i].select: 2061 continue 2062 2063 # Unit vector. 2064 if not hasattr(self.relax.data.res[self.run][i], 'xh_vect'): 2065 raise RelaxNoVectorsError, self.run 2066 2067 # Test if the nucleus type has been set. 2068 if not hasattr(self.relax.data, 'gx'): 2069 raise RelaxNucleusError 2070 2071 # Test if the model-free parameter values are set for minimising diffusion tensor parameters by themselves. 2072 if self.param_set == 'diff': 2073 # Loop over the sequence. 2074 for i in xrange(len(self.relax.data.res[self.run])): 2075 unset_param = self.are_mf_params_set(i) 2076 if unset_param != None: 2077 raise RelaxNoValueError, unset_param 2078 2079 # Print out. 2080 if self.print_flag >= 1: 2081 if self.param_set == 'mf': 2082 print "Only the model-free parameters for single residues will be used." 2083 elif self.param_set == 'local_mf': 2084 print "Only a local tm value together with the model-free parameters for single residues will be used." 2085 elif self.param_set == 'diff': 2086 print "Only diffusion tensor parameters will be used." 2087 elif self.param_set == 'all': 2088 print "The diffusion tensor parameters together with the model-free parameters for all residues will be used." 2089 2090 # Count the total number of residues and test if the CSA and bond length values have been set. 2091 num_res = 0 2092 for i in xrange(len(self.relax.data.res[self.run])): 2093 # Skip unselected residues. 2094 if not self.relax.data.res[self.run][i].select: 2095 continue 2096 2097 # CSA value. 2098 if not hasattr(self.relax.data.res[self.run][i], 'csa') or self.relax.data.res[self.run][i].csa == None: 2099 raise RelaxNoValueError, "CSA" 2100 2101 # Bond length value. 2102 if not hasattr(self.relax.data.res[self.run][i], 'r') or self.relax.data.res[self.run][i].r == None: 2103 raise RelaxNoValueError, "bond length" 2104 2105 # Increment the number of residues. 2106 num_res = num_res + 1 2107 2108 # Number of residues, minimisation instances, and data sets for each parameter set type. 2109 if self.param_set == 'mf' or self.param_set == 'local_tm': 2110 num_instances = len(self.relax.data.res[self.run]) 2111 num_data_sets = 1 2112 num_res = 1 2113 elif self.param_set == 'diff' or self.param_set == 'all': 2114 num_instances = 1 2115 num_data_sets = len(self.relax.data.res[self.run]) 2116 2117 # Number of residues for the calculate function. 2118 if min_algor == 'calc' and min_options != None: 2119 num_res = 1 2120 2121 # Number of residues, minimisation instances, and data sets for the back-calculate function. 2122 if min_algor == 'back_calc': 2123 num_instances = 1 2124 num_data_sets = 0 2125 num_res = 1 2126 2127 # Loop over the minimisation instances. 2128 for i in xrange(num_instances): 2129 # Set the residue index. 2130 if min_algor == 'back_calc': 2131 index = min_options[0] 2132 else: 2133 index = i 2134 2135 # Individual residue stuff. 2136 if (self.param_set == 'mf' or self.param_set == 'local_tm') and not min_algor == 'back_calc': 2137 # Skip unselected residues. 2138 if not self.relax.data.res[self.run][i].select: 2139 continue 2140 2141 # Skip residues where there is no data or errors. 2142 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not hasattr(self.relax.data.res[self.run][i], 'relax_error'): 2143 continue 2144 2145 # Single residue. 2146 if min_algor == 'calc' and min_options != None and min_options != self.relax.data.res[self.run][i].num: 2147 continue 2148 2149 # Parameter vector and diagonal scaling. 2150 if min_algor == 'back_calc': 2151 # Create the initial parameter vector. 2152 self.param_vector = self.assemble_param_vector(index=index) 2153 2154 # Diagonal scaling. 2155 self.scaling_matrix = None 2156 2157 else: 2158 # Create the initial parameter vector. 2159 self.param_vector = self.assemble_param_vector(index=index, sim_index=sim_index) 2160 2161 # Diagonal scaling. 2162 self.assemble_scaling_matrix(index=index, scaling=scaling) 2163 self.param_vector = matrixmultiply(inverse(self.scaling_matrix), self.param_vector) 2164 2165 # Get the grid search minimisation options. 2166 if match('^[Gg]rid', min_algor): 2167 min_options = self.grid_search_setup(index=index) 2168 2169 # Scaling of values for the set function. 2170 if match('^[Ss]et', min_algor): 2171 min_options = matrixmultiply(inverse(self.scaling_matrix), min_options) 2172 2173 # Linear constraints. 2174 if constraints and min_algor != 'calc': 2175 A, b = self.linear_constraints(index=index) 2176 2177 # Print out. 2178 if self.print_flag >= 1: 2179 # Individual residue stuff. 2180 if self.param_set == 'mf' or self.param_set == 'local_tm': 2181 if self.print_flag >= 2: 2182 print "\n\n" 2183 string = "Fitting to residue: " + `self.relax.data.res[self.run][index].num` + " " + self.relax.data.res[self.run][index].name 2184 print "\n\n" + string 2185 print len(string) * '~' 2186 if match('^[Gg]rid', min_algor): 2187 print "Unconstrained grid search size: " + `self.grid_size` + " (constraints may decrease this size).\n" 2188 2189 # Initialise the iteration counter and function, gradient, and Hessian call counters. 2190 self.iter_count = 0 2191 self.f_count = 0 2192 self.g_count = 0 2193 self.h_count = 0 2194 2195 # Initialise the data structures for the model-free function. 2196 relax_data = [] 2197 relax_error = [] 2198 equations = [] 2199 param_types = [] 2200 param_values = None 2201 r = [] 2202 csa = [] 2203 num_frq = [] 2204 frq = [] 2205 num_ri = [] 2206 remap_table = [] 2207 noe_r1_table = [] 2208 ri_labels = [] 2209 num_params = [] 2210 xh_unit_vectors = [] 2211 if self.param_set == 'local_tm': 2212 mf_params = [] 2213 elif self.param_set == 'diff': 2214 param_values = [] 2215 2216 # Set up the data for the back_calc function. 2217 if min_algor == 'back_calc': 2218 # The data. 2219 relax_data = [0.0] 2220 relax_error = [0.000001] 2221 equations = [self.relax.data.res[self.run][index].equation] 2222 param_types = [self.relax.data.res[self.run][index].params] 2223 r = [self.relax.data.res[self.run][index].r] 2224 csa = [self.relax.data.res[self.run][index].csa] 2225 num_frq = [1] 2226 frq = [[min_options[3]]] 2227 num_ri = [1] 2228 remap_table = [[0]] 2229 noe_r1_table = [[None]] 2230 ri_labels = [[min_options[1]]] 2231 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'iso': 2232 xh_unit_vectors = [self.relax.data.res[self.run][index].xh_vect] 2233 else: 2234 xh_unit_vectors = [None] 2235 2236 # Count the number of model-free parameters for the residue index. 2237 num_params = [len(self.relax.data.res[self.run][index].params)] 2238 2239 # Loop over the number of data sets. 2240 for j in xrange(num_data_sets): 2241 # Set the sequence index. 2242 if self.param_set == 'mf' or self.param_set == 'local_tm': 2243 seq_index = i 2244 else: 2245 seq_index = j 2246 2247 # Alias the data structure. 2248 data = self.relax.data.res[self.run][seq_index] 2249 2250 # Skip unselected residues. 2251 if not data.select: 2252 continue 2253 2254 # Skip residues where there is no data or errors. 2255 if not hasattr(data, 'relax_data') or not hasattr(data, 'relax_error'): 2256 continue 2257 2258 # Make sure that the errors are strictly positive numbers. 2259 for k in xrange(len(data.relax_error)): 2260 if data.relax_error[k] == 0.0: 2261 raise RelaxError, "Zero error for residue '" + `data.num` + " " + data.name + "', minimisation not possible." 2262 elif data.relax_error[k] < 0.0: 2263 raise RelaxError, "Negative error for residue '" + `data.num` + " " + data.name + "', minimisation not possible." 2264 2265 # Repackage the data. 2266 if sim_index == None: 2267 relax_data.append(data.relax_data) 2268 else: 2269 relax_data.append(data.relax_sim_data[sim_index]) 2270 relax_error.append(data.relax_error) 2271 equations.append(data.equation) 2272 param_types.append(data.params) 2273 num_frq.append(data.num_frq) 2274 frq.append(data.frq) 2275 num_ri.append(data.num_ri) 2276 remap_table.append(data.remap_table) 2277 noe_r1_table.append(data.noe_r1_table) 2278 ri_labels.append(data.ri_labels) 2279 if sim_index == None: 2280 r.append(data.r) 2281 csa.append(data.csa) 2282 else: 2283 r.append(data.r_sim[sim_index]) 2284 csa.append(data.csa_sim[sim_index]) 2285 2286 # Model-free parameter values. 2287 if self.param_set == 'local_tm': 2288 pass 2289 2290 # Vectors. 2291 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'iso': 2292 xh_unit_vectors.append(data.xh_vect) 2293 else: 2294 xh_unit_vectors.append(None) 2295 2296 # Count the number of model-free parameters for the residue index. 2297 num_params.append(len(data.params)) 2298 2299 # Repackage the parameter values for minimising just the diffusion tensor parameters. 2300 if self.param_set == 'diff': 2301 param_values.append(self.assemble_param_vector(param_set='mf')) 2302 2303 # Convert to Numeric arrays. 2304 for k in xrange(len(relax_data)): 2305 relax_data[k] = array(relax_data[k], Float64) 2306 relax_error[k] = array(relax_error[k], Float64) 2307 2308 # Diffusion tensor type. 2309 if self.param_set == 'local_tm': 2310 diff_type = 'iso' 2311 else: 2312 diff_type = self.relax.data.diff[self.run].type 2313 2314 # Package the diffusion tensor parameters. 2315 diff_params = None 2316 if self.param_set == 'mf': 2317 # Alias. 2318 data = self.relax.data.diff[self.run] 2319 2320 # Isotropic diffusion. 2321 if diff_type == 'iso': 2322 diff_params = [data.tm] 2323 2324 # Axially symmetric diffusion. 2325 elif diff_type == 'axial': 2326 diff_params = [data.tm, data.Da, data.theta, data.phi] 2327 2328 # Anisotropic diffusion. 2329 elif diff_type == 'aniso': 2330 diff_params = [data.tm, data.Da, data.Dr, data.alpha, data.beta, data.gamma] 2331 elif min_algor == 'back_calc' and self.param_set == 'local_tm': 2332 # Isotropic diffusion. 2333 diff_params = [self.relax.data.res[self.run][index].tm] 2334 2335 2336 2337 # Initialise the function to minimise. 2338 ###################################### 2339 2340 self.mf = Mf(init_params=self.param_vector, param_set=self.param_set, diff_type=diff_type, diff_params=diff_params, scaling_matrix=self.scaling_matrix, num_res=num_res, equations=equations, param_types=param_types, param_values=param_values, relax_data=relax_data, errors=relax_error, bond_length=r, csa=csa, num_frq=num_frq, frq=frq, num_ri=num_ri, remap_table=remap_table, noe_r1_table=noe_r1_table, ri_labels=ri_labels, gx=self.relax.data.gx, gh=self.relax.data.gh, g_ratio=self.relax.data.g_ratio, h_bar=self.relax.data.h_bar, mu0=self.relax.data.mu0, num_params=num_params, vectors=xh_unit_vectors) 2341 2342 2343 # Setup the minimisation algorithm when constraints are present. 2344 ################################################################ 2345 2346 if constraints and not match('^[Gg]rid', min_algor) and min_algor != 'calc': 2347 algor = min_options[0] 2348 else: 2349 algor = min_algor 2350 2351 2352 # Levenberg-Marquardt minimisation. 2353 ################################### 2354 2355 if match('[Ll][Mm]$', algor) or match('[Ll]evenburg-[Mm]arquardt$', algor): 2356 # Total number of ri. 2357 number_ri = 0 2358 for k in xrange(len(relax_error)): 2359 number_ri = number_ri + len(relax_error[k]) 2360 2361 # Reconstruct the error data structure. 2362 lm_error = zeros(number_ri, Float64) 2363 index = 0 2364 for k in xrange(len(relax_error)): 2365 lm_error[index:index+len(relax_error[k])] = relax_error[k] 2366 index = index + len(relax_error[k]) 2367 2368 min_options = min_options + (self.mf.lm_dri, lm_error) 2369 2370 2371 # Chi-squared calculation. 2372 ########################## 2373 2374 if min_algor == 'calc': 2375 # Chi-squared. 2376 try: 2377 self.relax.data.res[self.run][i].chi2 = self.mf.func(self.param_vector) 2378 except OverflowError: 2379 self.relax.data.res[self.run][i].chi2 = 1e200 2380 2381 # Exit the function. 2382 return 2383 2384 2385 # Back-calculation. 2386 ################### 2387 2388 if min_algor == 'back_calc': 2389 return self.mf.calc_ri() 2390 2391 2392 # Minimisation. 2393 ############### 2394 2395 if constraints: 2396 results = generic_minimise(func=self.mf.func, dfunc=self.mf.dfunc, d2func=self.mf.d2func, args=(), x0=self.param_vector, min_algor=min_algor, min_options=min_options, func_tol=func_tol, grad_tol=grad_tol, maxiter=max_iterations, A=A, b=b, full_output=1, print_flag=print_flag) 2397 else: 2398 results = generic_minimise(func=self.mf.func, dfunc=self.mf.dfunc, d2func=self.mf.d2func, args=(), x0=self.param_vector, min_algor=min_algor, min_options=min_options, func_tol=func_tol, grad_tol=grad_tol, maxiter=max_iterations, full_output=1, print_flag=print_flag) 2399 if results == None: 2400 return 2401 self.param_vector, self.func, iter, fc, gc, hc, self.warning = results 2402 self.iter_count = self.iter_count + iter 2403 self.f_count = self.f_count + fc 2404 self.g_count = self.g_count + gc 2405 self.h_count = self.h_count + hc 2406 2407 # Scaling. 2408 if scaling: 2409 self.param_vector = matrixmultiply(self.scaling_matrix, self.param_vector) 2410 2411 # Disassemble the parameter vector. 2412 self.disassemble_param_vector(index=index, sim_index=sim_index) 2413 2414 # Monte Carlo minimisation statistics. 2415 if sim_index != None: 2416 # Sequence specific minimisation statistics. 2417 if self.param_set == 'mf' or self.param_set == 'local_tm': 2418 # Chi-squared statistic. 2419 self.relax.data.res[self.run][i].chi2_sim[sim_index] = self.func 2420 2421 # Iterations. 2422 self.relax.data.res[self.run][i].iter_sim[sim_index] = self.iter_count 2423 2424 # Function evaluations. 2425 self.relax.data.res[self.run][i].f_count_sim[sim_index] = self.f_count 2426 2427 # Gradient evaluations. 2428 self.relax.data.res[self.run][i].g_count_sim[sim_index] = self.g_count 2429 2430 # Hessian evaluations. 2431 self.relax.data.res[self.run][i].h_count_sim[sim_index] = self.h_count 2432 2433 # Warning. 2434 self.relax.data.res[self.run][i].warning_sim[sim_index] = self.warning 2435 2436 # Global minimisation statistics. 2437 elif self.param_set == 'diff' or self.param_set == 'all': 2438 # Chi-squared statistic. 2439 self.relax.data.chi2_sim[self.run][sim_index] = self.func 2440 2441 # Iterations. 2442 self.relax.data.iter_sim[self.run][sim_index] = self.iter_count 2443 2444 # Function evaluations. 2445 self.relax.data.f_count_sim[self.run][sim_index] = self.f_count 2446 2447 # Gradient evaluations. 2448 self.relax.data.g_count_sim[self.run][sim_index] = self.g_count 2449 2450 # Hessian evaluations. 2451 self.relax.data.h_count_sim[self.run][sim_index] = self.h_count 2452 2453 # Warning. 2454 self.relax.data.warning_sim[self.run][sim_index] = self.warning 2455 2456 # Normal statistics. 2457 else: 2458 # Sequence specific minimisation statistics. 2459 if self.param_set == 'mf' or self.param_set == 'local_tm': 2460 # Chi-squared statistic. 2461 self.relax.data.res[self.run][i].chi2 = self.func 2462 2463 # Iterations. 2464 self.relax.data.res[self.run][i].iter = self.iter_count 2465 2466 # Function evaluations. 2467 self.relax.data.res[self.run][i].f_count = self.f_count 2468 2469 # Gradient evaluations. 2470 self.relax.data.res[self.run][i].g_count = self.g_count 2471 2472 # Hessian evaluations. 2473 self.relax.data.res[self.run][i].h_count = self.h_count 2474 2475 # Warning. 2476 self.relax.data.res[self.run][i].warning = self.warning 2477 2478 # Global minimisation statistics. 2479 elif self.param_set == 'diff' or self.param_set == 'all': 2480 # Chi-squared statistic. 2481 self.relax.data.chi2[self.run] = self.func 2482 2483 # Iterations. 2484 self.relax.data.iter[self.run] = self.iter_count 2485 2486 # Function evaluations. 2487 self.relax.data.f_count[self.run] = self.f_count 2488 2489 # Gradient evaluations. 2490 self.relax.data.g_count[self.run] = self.g_count 2491 2492 # Hessian evaluations. 2493 self.relax.data.h_count[self.run] = self.h_count 2494 2495 # Warning. 2496 self.relax.data.warning[self.run] = self.warning

2497 2498

2499 - def model_setup(self, run=None, model=None, equation=None, params=None, res_num=None):

2500 """Function for updating various data structures depending on the model selected.""" 2501 2502 # Test that no diffusion tensor exists for the run if tm is a parameter in the model. 2503 for param in params: 2504 if param == 'tm' and self.relax.data.diff.has_key(run): 2505 raise RelaxTensorError, run 2506 2507 # Loop over the sequence. 2508 for i in xrange(len(self.relax.data.res[run])): 2509 # Skip unselected residues. 2510 if not self.relax.data.res[run][i].select: 2511 continue 2512 2513 # If res_num is set, then skip all other residues. 2514 if res_num != None and res_num != self.relax.data.res[run][i].num: 2515 continue 2516 2517 # Initialise the data structures (if needed). 2518 self.initialise_data(self.relax.data.res[run][i], run) 2519 2520 # Model-free model, equation, and parameter types. 2521 self.relax.data.res[run][i].model = model 2522 self.relax.data.res[run][i].equation = equation 2523 self.relax.data.res[run][i].params = params

2524 2525

2526 - def model_statistics(self, run=None, instance=None, min_instances=None, num_instances=None):

2527 """Function for returning k, n, and chi2. 2528 2529 k - number of parameters. 2530 n - number of data points. 2531 chi2 - the chi-squared value. 2532 """ 2533 2534 # Arguments. 2535 self.run = run 2536 2537 # Determine the parameter set type. 2538 self.param_set = self.determine_param_set_type() 2539 2540 # Consolidate the instances to the minimum number. 2541 consolidate = 0 2542 if min_instances == 1 and min_instances != num_instances: 2543 consolidate = 1 2544 2545 # Sequence specific data. 2546 if (self.param_set == 'mf' or self.param_set == 'local_tm') and not consolidate: 2547 # Missing data sets. 2548 if not hasattr(self.relax.data.res[self.run][instance], 'relax_data'): 2549 return None, None, None 2550 2551 # Count the number of parameters. 2552 self.param_vector = self.assemble_param_vector(index=instance) 2553 k = len(self.param_vector) 2554 2555 # Count the number of data points. 2556 n = len(self.relax.data.res[self.run][instance].relax_data) 2557 2558 # The chi2 value. 2559 chi2 = self.relax.data.res[self.run][instance].chi2 2560 2561 # Consolidated sequence specific data. 2562 elif (self.param_set == 'mf' or self.param_set == 'local_tm') and consolidate: 2563 # Initialise. 2564 k = 0 2565 n = 0 2566 chi2 = 0 2567 2568 # Loop over the sequence. 2569 for i in xrange(len(self.relax.data.res[self.run])): 2570 # Skip unselected residues. 2571 if not self.relax.data.res[self.run][i].select: 2572 continue 2573 2574 # Count the number of parameters. 2575 self.param_vector = self.assemble_param_vector(index=i) 2576 k = k + len(self.param_vector) 2577 2578 # Count the number of data points. 2579 n = n + len(self.relax.data.res[self.run][i].relax_data) 2580 2581 # The chi2 value. 2582 chi2 = chi2 + self.relax.data.res[self.run][i].chi2 2583 2584 # Other data. 2585 elif self.param_set == 'diff' or self.param_set == 'all': 2586 # Count the number of parameters. 2587 self.param_vector = self.assemble_param_vector() 2588 k = len(self.param_vector) 2589 2590 # Count the number of data points. 2591 n = 0 2592 for i in xrange(len(self.relax.data.res[self.run])): 2593 # Skip unselected residues. 2594 if not self.relax.data.res[self.run][i].select: 2595 continue 2596 2597 n = n + len(self.relax.data.res[self.run][i].relax_data) 2598 2599 # The chi2 value. 2600 chi2 = self.relax.data.chi2[self.run] 2601 2602 2603 # Return the data. 2604 return k, n, chi2

2605 2606

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

2608 """Function for returning the number of instances.""" 2609 2610 # Arguments. 2611 self.run = run 2612 2613 # Test if sequence data is loaded. 2614 if not self.relax.data.res.has_key(self.run): 2615 return 0 2616 2617 # Determine the parameter set type. 2618 self.param_set = self.determine_param_set_type() 2619 2620 # Sequence specific data. 2621 if self.param_set == 'mf' or self.param_set == 'local_tm': 2622 return len(self.relax.data.res[self.run]) 2623 2624 # Other data. 2625 elif self.param_set == 'diff' or self.param_set == 'all': 2626 return 1

2627 2628

2629 - def read_columnar_col_numbers(self, header):

2630 """Function for sorting the column numbers from the columnar formatted results file.""" 2631 2632 # Initialise the hash. 2633 self.col = {} 2634 2635 # Loop over the columns. 2636 for i in xrange(len(header)): 2637 # Residue info. 2638 if header[i] == 'Num': 2639 self.col['num'] = i 2640 elif header[i] == 'Name': 2641 self.col['name'] = i 2642 elif header[i] == 'Selected': 2643 self.col['select'] = i 2644 elif header[i] == 'Data_set': 2645 self.col['data_set'] = i 2646 elif header[i] == 'Nucleus': 2647 self.col['nucleus'] = i 2648 elif header[i] == 'Model': 2649 self.col['model'] = i 2650 elif header[i] == 'Equation': 2651 self.col['eqi'] = i 2652 elif header[i] == 'Params': 2653 self.col['params'] = i 2654 elif header[i] == 'Param_set': 2655 self.col['param_set'] = i 2656 2657 # Parameters. 2658 elif header[i] == 'S2': 2659 self.col['s2'] = i 2660 elif header[i] == 'S2f': 2661 self.col['s2f'] = i 2662 elif header[i] == 'S2s': 2663 self.col['s2s'] = i 2664 elif header[i] == 'Local_tm_(ns)': 2665 self.col['local_tm'] = i 2666 elif header[i] == 'te_(ps)': 2667 self.col['te'] = i 2668 elif header[i] == 'tf_(ps)': 2669 self.col['tf'] = i 2670 elif header[i] == 'ts_(ps)': 2671 self.col['ts'] = i 2672 elif header[i] == 'Rex_(1st_field)': 2673 self.col['rex'] = i 2674 elif header[i] == 'Bond_length_(A)': 2675 self.col['r'] = i 2676 elif header[i] == 'CSA_(ppm)': 2677 self.col['csa'] = i 2678 2679 # Minimisation info. 2680 elif header[i] == 'Chi-squared': 2681 self.col['chi2'] = i 2682 elif header[i] == 'Iter': 2683 self.col['iter'] = i 2684 elif header[i] == 'f_count': 2685 self.col['f_count'] = i 2686 elif header[i] == 'g_count': 2687 self.col['g_count'] = i 2688 elif header[i] == 'h_count': 2689 self.col['h_count'] = i 2690 elif header[i] == 'Warning': 2691 self.col['warn'] = i 2692 2693 # Diffusion tensor. 2694 elif header[i] == 'Diff_type': 2695 self.col['diff_type'] = i 2696 elif header[i] == 'tm_(s)': 2697 self.col['tm'] = i 2698 elif header[i] == 'Da_(1/s)': 2699 self.col['da'] = i 2700 elif header[i] == 'theta_(deg)': 2701 self.col['theta'] = i 2702 elif header[i] == 'phi_(deg)': 2703 self.col['phi'] = i 2704 elif header[i] == 'Da_(1/s)': 2705 self.col['da'] = i 2706 elif header[i] == 'Dr_(1/s)': 2707 self.col['dr'] = i 2708 elif header[i] == 'alpha_(deg)': 2709 self.col['alpha'] = i 2710 elif header[i] == 'beta_(deg)': 2711 self.col['beta'] = i 2712 elif header[i] == 'gamma_(deg)': 2713 self.col['gamma'] = i 2714 2715 # PDB and XH vector. 2716 elif header[i] == 'PDB': 2717 self.col['pdb'] = i 2718 elif header[i] == 'PDB_model': 2719 self.col['pdb_model'] = i 2720 elif header[i] == 'PDB_heteronuc': 2721 self.col['pdb_heteronuc'] = i 2722 elif header[i] == 'PDB_proton': 2723 self.col['pdb_proton'] = i 2724 elif header[i] == 'XH_vector': 2725 self.col['xh_vect'] = i 2726 2727 # Relaxation data. 2728 elif header[i] == 'Ri_labels': 2729 self.col['ri_labels'] = i 2730 elif header[i] == 'Remap_table': 2731 self.col['remap_table'] = i 2732 elif header[i] == 'Frq_labels': 2733 self.col['frq_labels'] = i 2734 elif header[i] == 'Frequencies': 2735 self.col['frq'] = i

2736 2737

2738 - def read_columnar_diff_tensor(self):

2739 """Function for setting up the diffusion tensor from the columnar formatted results file.""" 2740 2741 # The diffusion tensor type. 2742 diff_type = self.file_line[self.col['diff_type']] 2743 if diff_type == 'None': 2744 diff_type = None 2745 2746 # Isotropic. 2747 if diff_type == 'iso': 2748 # Convert the parameters to floating point numbers. 2749 try: 2750 tm = float(self.file_line[self.col['tm']]) 2751 except ValueError: 2752 # Errors or simulation values set to None. 2753 if self.data_set != 'value' and self.file_line[self.col['tm']] == 'None': 2754 return 2755 2756 # Genuine error. 2757 raise RelaxError, "The diffusion tensor parameters are not numbers." 2758 2759 # Values. 2760 if self.data_set == 'value': 2761 diff_params = tm 2762 2763 # Errors. 2764 elif self.data_set == 'error': 2765 self.relax.data.diff[self.run].tm_err = tm 2766 2767 # Simulation values. 2768 else: 2769 # Create the data structure if it doesn't exist. 2770 if not hasattr(self.relax.data.diff[self.run], 'tm_sim'): 2771 self.relax.data.diff[self.run].tm_sim = [] 2772 2773 # Append the value. 2774 self.relax.data.diff[self.run].tm_sim.append(tm) 2775 2776 2777 # Axial symmetery. 2778 elif diff_type == 'axial' or diff_type == 'oblate' or diff_type == 'prolate': 2779 # Convert the parameters to floating point numbers. 2780 try: 2781 tm = float(self.file_line[self.col['tm']]) 2782 Da = float(self.file_line[self.col['da']]) 2783 theta = float(self.file_line[self.col['theta']]) / 360.0 * 2.0 * pi 2784 phi = float(self.file_line[self.col['phi']]) / 360.0 * 2.0 * pi 2785 except ValueError: 2786 # Errors or simulation values set to None. 2787 if self.data_set != 'value' and self.file_line[self.col['tm']] == 'None': 2788 return 2789 2790 # Genuine error. 2791 raise RelaxError, "The diffusion tensor parameters are not numbers." 2792 2793 # Values. 2794 if self.data_set == 'value': 2795 diff_params = [tm, Da, theta, phi] 2796 2797 # Errors. 2798 elif self.data_set == 'error': 2799 self.relax.data.diff[self.run].tm_err = tm 2800 self.relax.data.diff[self.run].Da_err = Da 2801 self.relax.data.diff[self.run].theta_err = theta 2802 self.relax.data.diff[self.run].phi_err = phi 2803 2804 # Simulation values. 2805 else: 2806 # Create the data structure if it doesn't exist. 2807 if not hasattr(self.relax.data.diff[self.run], 'tm_sim'): 2808 self.relax.data.diff[self.run].tm_sim = [] 2809 if not hasattr(self.relax.data.diff[self.run], 'Da_sim'): 2810 self.relax.data.diff[self.run].Da_sim = [] 2811 if not hasattr(self.relax.data.diff[self.run], 'theta_sim'): 2812 self.relax.data.diff[self.run].theta_sim = [] 2813 if not hasattr(self.relax.data.diff[self.run], 'phi_sim'): 2814 self.relax.data.diff[self.run].phi_sim = [] 2815 2816 # Append the value. 2817 self.relax.data.diff[self.run].tm_sim.append(tm) 2818 self.relax.data.diff[self.run].Da_sim.append(Da) 2819 self.relax.data.diff[self.run].theta_sim.append(theta) 2820 self.relax.data.diff[self.run].phi_sim.append(phi) 2821 2822 2823 # Anisotropic. 2824 elif diff_type == 'aniso': 2825 # Convert the parameters to floating point numbers. 2826 try: 2827 tm = float(self.file_line[self.col['tm']]) 2828 Da = float(self.file_line[self.col['da']]) 2829 Dr = float(self.file_line[self.col['dr']]) 2830 alpha = float(self.file_line[self.col['alpha']]) / 360.0 * 2.0 * pi 2831 beta = float(self.file_line[self.col['beta']]) / 360.0 * 2.0 * pi 2832 gamma = float(self.file_line[self.col['gamma']]) / 360.0 * 2.0 * pi 2833 except ValueError: 2834 # Errors or simulation values set to None. 2835 if self.data_set != 'value' and self.file_line[self.col['tm']] == 'None': 2836 return 2837 2838 # Genuine error. 2839 raise RelaxError, "The diffusion tensor parameters are not numbers." 2840 2841 # Values. 2842 if self.data_set == 'value': 2843 diff_params = [tm, Da, Dr, alpha, beta, gamma] 2844 2845 # Errors. 2846 elif self.data_set == 'error': 2847 self.relax.data.diff[self.run].tm_err = tm 2848 self.relax.data.diff[self.run].Da_err = Da 2849 self.relax.data.diff[self.run].Dr_err = Dr 2850 self.relax.data.diff[self.run].alpha_err = alpha 2851 self.relax.data.diff[self.run].beta_err = beta 2852 self.relax.data.diff[self.run].gamma_err = gamma 2853 2854 # Simulation values. 2855 else: 2856 # Create the data structure if it doesn't exist. 2857 if not hasattr(self.relax.data.diff[self.run], 'tm_sim'): 2858 self.relax.data.diff[self.run].tm_sim = [] 2859 if not hasattr(self.relax.data.diff[self.run], 'Da_sim'): 2860 self.relax.data.diff[self.run].Da_sim = [] 2861 if not hasattr(self.relax.data.diff[self.run], 'Dr_sim'): 2862 self.relax.data.diff[self.run].Dr_sim = [] 2863 if not hasattr(self.relax.data.diff[self.run], 'alpha_sim'): 2864 self.relax.data.diff[self.run].alpha_sim = [] 2865 if not hasattr(self.relax.data.diff[self.run], 'beta_sim'): 2866 self.relax.data.diff[self.run].beta_sim = [] 2867 if not hasattr(self.relax.data.diff[self.run], 'gamma_sim'): 2868 self.relax.data.diff[self.run].gamma_sim = [] 2869 2870 # Append the value. 2871 self.relax.data.diff[self.run].tm_sim.append(tm) 2872 self.relax.data.diff[self.run].Da_sim.append(Da) 2873 self.relax.data.diff[self.run].Dr_sim.append(Dr) 2874 self.relax.data.diff[self.run].alpha_sim.append(alpha) 2875 self.relax.data.diff[self.run].beta_sim.append(beta) 2876 self.relax.data.diff[self.run].gamma_sim.append(gamma) 2877 2878 2879 # Set the diffusion tensor. 2880 if self.data_set == 'value' and diff_type: 2881 # Sort out the axial type. 2882 axial_type = None 2883 if diff_type == 'oblate' or diff_type == 'prolate': 2884 axial_type = diff_type 2885 2886 # Set the diffusion tensor. 2887 self.relax.generic.diffusion_tensor.set(run=self.run, params=diff_params, angle_units='rad', axial_type=axial_type)

2888 2889

2890 - def read_columnar_find_index(self):

2891 """Function for generating the sequence and or returning the residue index.""" 2892 2893 # Residue number and name. 2894 try: 2895 self.res_num = int(self.file_line[self.col['num']]) 2896 except ValueError: 2897 raise RelaxError, "The residue number " + self.file_line[self.col['num']] + " is not an integer." 2898 self.res_name = self.file_line[self.col['name']] 2899 2900 # Find the residue index. 2901 res_index = None 2902 for j in xrange(len(self.relax.data.res[self.run])): 2903 if self.relax.data.res[self.run][j].num == self.res_num and self.relax.data.res[self.run][j].name == self.res_name: 2904 res_index = j 2905 break 2906 if res_index == None: 2907 raise RelaxError, "Residue " + `self.res_num` + " " + self.res_name + " cannot be found in the sequence." 2908 2909 # Return the index. 2910 return res_index

2911 2912

2913 - def read_columnar_model_free_data(self):

2914 """Function for reading the model-free data.""" 2915 2916 # Reassign data structure. 2917 data = self.relax.data.res[self.run][self.res_index] 2918 2919 # Set up the model-free models. 2920 if self.data_set == 'value': 2921 model = self.file_line[self.col['model']] 2922 equation = self.file_line[self.col['eqi']] 2923 params = eval(self.file_line[self.col['params']]) 2924 if model and equation and params: 2925 self.model_setup(self.run, model=model, equation=equation, params=params, res_num=self.res_num) 2926 2927 # Values. 2928 if self.data_set == 'value': 2929 # S2. 2930 try: 2931 data.s2 = float(self.file_line[self.col['s2']]) 2932 except ValueError: 2933 data.s2 = None 2934 2935 # S2f. 2936 try: 2937 data.s2f = float(self.file_line[self.col['s2f']]) 2938 except ValueError: 2939 data.s2f = None 2940 2941 # S2s. 2942 try: 2943 data.s2s = float(self.file_line[self.col['s2s']]) 2944 except ValueError: 2945 data.s2s = None 2946 2947 # Local tm. 2948 try: 2949 data.tm = float(self.file_line[self.col['local_tm']]) * 1e-9 2950 except ValueError: 2951 data.tm = None 2952 2953 # te. 2954 try: 2955 data.te = float(self.file_line[self.col['te']]) * 1e-12 2956 except ValueError: 2957 data.te = None 2958 2959 # tf. 2960 try: 2961 data.tf = float(self.file_line[self.col['tf']]) * 1e-12 2962 except ValueError: 2963 data.tf = None 2964 2965 # ts. 2966 try: 2967 data.ts = float(self.file_line[self.col['ts']]) * 1e-12 2968 except ValueError: 2969 data.ts = None 2970 2971 # Rex. 2972 try: 2973 data.rex = float(self.file_line[self.col['rex']]) / (2.0 * pi * data.frq[0])**2 2974 except: 2975 data.rex = None 2976 2977 # Bond length. 2978 try: 2979 data.r = float(self.file_line[self.col['r']]) * 1e-10 2980 except ValueError: 2981 data.r = None 2982 2983 # CSA. 2984 try: 2985 data.csa = float(self.file_line[self.col['csa']]) * 1e-6 2986 except ValueError: 2987 data.csa = None 2988 2989 # Minimisation details (global minimisation results). 2990 if self.param_set == 'diff' or self.param_set == 'all': 2991 self.relax.data.chi2[self.run] = eval(self.file_line[self.col['chi2']]) 2992 self.relax.data.iter[self.run] = eval(self.file_line[self.col['iter']]) 2993 self.relax.data.f_count[self.run] = eval(self.file_line[self.col['f_count']]) 2994 self.relax.data.g_count[self.run] = eval(self.file_line[self.col['g_count']]) 2995 self.relax.data.h_count[self.run] = eval(self.file_line[self.col['h_count']]) 2996 if self.file_line[self.col['warn']] == 'None': 2997 self.relax.data.warning[self.run] = None 2998 else: 2999 self.relax.data.warning[self.run] = replace(self.file_line[self.col['warn']], '_', ' ') 3000 3001 # Minimisation details (individual residue results). 3002 else: 3003 data.chi2 = eval(self.file_line[self.col['chi2']]) 3004 data.iter = eval(self.file_line[self.col['iter']]) 3005 data.f_count = eval(self.file_line[self.col['f_count']]) 3006 data.g_count = eval(self.file_line[self.col['g_count']]) 3007 data.h_count = eval(self.file_line[self.col['h_count']]) 3008 if self.file_line[self.col['warn']] == 'None': 3009 data.warning = None 3010 else: 3011 data.warning = replace(self.file_line[self.col['warn']], '_', ' ') 3012 3013 # Errors. 3014 if self.data_set == 'error': 3015 # S2. 3016 try: 3017 data.s2_err = float(self.file_line[self.col['s2']]) 3018 except ValueError: 3019 data.s2_err = None 3020 3021 # S2f. 3022 try: 3023 data.s2f_err = float(self.file_line[self.col['s2f']]) 3024 except ValueError: 3025 data.s2f_err = None 3026 3027 # S2s. 3028 try: 3029 data.s2s_err = float(self.file_line[self.col['s2s']]) 3030 except ValueError: 3031 data.s2s_err = None 3032 3033 # Local tm. 3034 try: 3035 data.tm_err = float(self.file_line[self.col['local_tm']]) * 1e-9 3036 except ValueError: 3037 data.tm_err = None 3038 3039 # te. 3040 try: 3041 data.te_err = float(self.file_line[self.col['te']]) * 1e-12 3042 except ValueError: 3043 data.te_err = None 3044 3045 # tf. 3046 try: 3047 data.tf_err = float(self.file_line[self.col['tf']]) * 1e-12 3048 except ValueError: 3049 data.tf_err = None 3050 3051 # ts. 3052 try: 3053 data.ts_err = float(self.file_line[self.col['ts']]) * 1e-12 3054 except ValueError: 3055 data.ts_err = None 3056 3057 # Rex. 3058 try: 3059 data.rex_err = float(self.file_line[self.col['rex']]) / (2.0 * pi * data.frq[0])**2 3060 except: 3061 data.rex_err = None 3062 3063 # Bond length. 3064 try: 3065 data.r_err = float(self.file_line[self.col['r']]) * 1e-10 3066 except ValueError: 3067 data.r_err = None 3068 3069 # CSA. 3070 try: 3071 data.csa_err = float(self.file_line[self.col['csa']]) * 1e-6 3072 except ValueError: 3073 data.csa_err = None 3074 3075 3076 # Construct the simulation data structures. 3077 if self.data_set == 'sim_0': 3078 # Get the parameter object names. 3079 param_names = self.data_names(set='params') 3080 3081 # Get the minimisation statistic object names. 3082 min_names = self.data_names(set='min') 3083 3084 # Loop over all the parameter names. 3085 for object_name in param_names: 3086 # Name for the simulation object. 3087 sim_object_name = object_name + '_sim' 3088 3089 # Create the simulation object. 3090 setattr(data, sim_object_name, []) 3091 3092 # Loop over all the minimisation object names. 3093 for object_name in min_names: 3094 # Name for the simulation object. 3095 sim_object_name = object_name + '_sim' 3096 3097 # Create the simulation object. 3098 if self.param_set == 'diff' or self.param_set == 'all': 3099 setattr(self.relax.data, sim_object_name, {}) 3100 object = getattr(self.relax.data, sim_object_name) 3101 object[self.run] = [] 3102 else: 3103 setattr(data, sim_object_name, []) 3104 3105 # Simulations. 3106 if self.data_set != 'value' and self.data_set != 'error': 3107 # S2. 3108 try: 3109 data.s2_sim.append(float(self.file_line[self.col['s2']])) 3110 except ValueError: 3111 data.s2_sim.append(None) 3112 3113 # S2f. 3114 try: 3115 data.s2f_sim.append(float(self.file_line[self.col['s2f']])) 3116 except ValueError: 3117 data.s2f_sim.append(None) 3118 3119 # S2s. 3120 try: 3121 data.s2s_sim.append(float(self.file_line[self.col['s2s']])) 3122 except ValueError: 3123 data.s2s_sim.append(None) 3124 3125 # Local tm. 3126 try: 3127 data.tm_sim.append(float(self.file_line[self.col['local_tm']]) * 1e-9) 3128 except ValueError: 3129 data.tm_sim.append(None) 3130 3131 # te. 3132 try: 3133 data.te_sim.append(float(self.file_line[self.col['te']]) * 1e-12) 3134 except ValueError: 3135 data.te_sim.append(None) 3136 3137 # tf. 3138 try: 3139 data.tf_sim.append(float(self.file_line[self.col['tf']]) * 1e-12) 3140 except ValueError: 3141 data.tf_sim.append(None) 3142 3143 # ts. 3144 try: 3145 data.ts_sim.append(float(self.file_line[self.col['ts']]) * 1e-12) 3146 except ValueError: 3147 data.ts_sim.append(None) 3148 3149 # Rex. 3150 try: 3151 data.rex_sim.append(float(self.file_line[self.col['rex']]) / (2.0 * pi * data.frq[0])**2) 3152 except: 3153 data.rex_sim.append(None) 3154 3155 # Bond length. 3156 try: 3157 data.r_sim.append(float(self.file_line[self.col['r']]) * 1e-10) 3158 except ValueError: 3159 data.r_sim.append(None) 3160 3161 # CSA. 3162 try: 3163 data.csa_sim.append(float(self.file_line[self.col['csa']]) * 1e-6) 3164 except ValueError: 3165 data.csa_sim.append(None) 3166 3167 # Minimisation details (global minimisation results). 3168 if self.param_set == 'diff' or self.param_set == 'all': 3169 self.relax.data.chi2_sim[self.run].append(eval(self.file_line[self.col['chi2']])) 3170 self.relax.data.iter_sim[self.run].append(eval(self.file_line[self.col['iter']])) 3171 self.relax.data.f_count_sim[self.run].append(eval(self.file_line[self.col['f_count']])) 3172 self.relax.data.g_count_sim[self.run].append(eval(self.file_line[self.col['g_count']])) 3173 self.relax.data.h_count_sim[self.run].append(eval(self.file_line[self.col['h_count']])) 3174 if self.file_line[self.col['warn']] == 'None': 3175 self.relax.data.warning_sim[self.run].append(None) 3176 else: 3177 self.relax.data.warning_sim[self.run].append(replace(self.file_line[self.col['warn']], '_', ' ')) 3178 3179 # Minimisation details (individual residue results). 3180 else: 3181 data.chi2_sim.append(eval(self.file_line[self.col['chi2']])) 3182 data.iter_sim.append(eval(self.file_line[self.col['iter']])) 3183 data.f_count_sim.append(eval(self.file_line[self.col['f_count']])) 3184 data.g_count_sim.append(eval(self.file_line[self.col['g_count']])) 3185 data.h_count_sim.append(eval(self.file_line[self.col['h_count']])) 3186 if self.file_line[self.col['warn']] == 'None': 3187 data.warning_sim.append(None) 3188 else: 3189 data.warning_sim.append(replace(self.file_line[self.col['warn']], '_', ' '))

3190 3191

3192 - def read_columnar_param_set(self):

3193 """Function for reading the parameter set.""" 3194 3195 # Extract the parameter set if it exists, otherwise return. 3196 if self.file_line[self.col['param_set']] != 'None': 3197 self.param_set = self.file_line[self.col['param_set']] 3198 else: 3199 return 3200 3201 # Local tm and model-free only parameter sets. 3202 if self.param_set == 'local_tm' or self.param_set == 'mf': 3203 diff_fixed = 1 3204 res_fixed = 0 3205 3206 # Diffusion tensor parameter set. 3207 elif self.param_set == 'diff': 3208 diff_fixed = 0 3209 res_fixed = 1 3210 3211 # 'all' parameter set. 3212 elif self.param_set == 'all': 3213 diff_fixed = 0 3214 res_fixed = 0 3215 3216 # No parameter set. 3217 elif self.param_set == 'None': 3218 self.param_set = None 3219 diff_fixed = None 3220 res_fixed = None 3221 3222 # Set the diffusion tensor fixed flag. 3223 if self.param_set != 'local_tm' and diff_fixed != None: 3224 self.relax.data.diff[self.run].fixed = diff_fixed 3225 3226 # Set the residue specific fixed flag. 3227 for i in xrange(len(self.relax.data.res[self.run])): 3228 if res_fixed != None: 3229 self.relax.data.res[self.run][i].fixed = res_fixed

3230 3231

3232 - def read_columnar_pdb(self, print_flag=1):

3233 """Function for reading the PDB file.""" 3234 3235 # File name. 3236 pdb = self.file_line[self.col['pdb']] 3237 3238 # PDB model. 3239 pdb_model = eval(self.file_line[self.col['pdb_model']]) 3240 3241 # Heteronucleus. 3242 if self.col.has_key('pdb_heteronuc'): 3243 pdb_heteronuc = self.file_line[self.col['pdb_heteronuc']] 3244 3245 # Proton. 3246 if self.col.has_key('pdb_proton'): 3247 pdb_proton = self.file_line[self.col['pdb_proton']] 3248 3249 # Load the PDB. 3250 if not pdb == 'None': 3251 self.relax.generic.pdb.load(run=self.run, file=pdb, model=pdb_model, heteronuc=pdb_heteronuc, proton=pdb_proton, calc_vectors=0, fail=0, print_flag=print_flag) 3252 return 1 3253 else: 3254 return 0

3255 3256

3257 - def read_columnar_relax_data(self):

3258 """Function for reading the relaxation data.""" 3259 3260 # Skip the error 'data_set'. 3261 if self.data_set == 'error': 3262 return 3263 3264 # Relaxation data structures. 3265 if not self.ri_labels: 3266 self.ri_labels = eval(self.file_line[self.col['ri_labels']]) 3267 self.remap_table = eval(self.file_line[self.col['remap_table']]) 3268 self.frq_labels = eval(self.file_line[self.col['frq_labels']]) 3269 self.frq = eval(self.file_line[self.col['frq']]) 3270 3271 # Test if the relaxation data is consistent. 3272 if self.ri_labels != eval(self.file_line[self.col['ri_labels']]) or self.remap_table != eval(self.file_line[self.col['remap_table']]) or self.frq_labels != eval(self.file_line[self.col['frq_labels']]) or self.frq != eval(self.file_line[self.col['frq']]): 3273 raise RelaxError, "The relaxation data is not consistent for all residues." 3274 3275 # No relaxation data. 3276 if not self.ri_labels: 3277 return 3278 3279 # Initialise the value and error arrays. 3280 values = [] 3281 errors = [] 3282 3283 # Loop over the relaxation data of the residue. 3284 for i in xrange(len(self.ri_labels)): 3285 # Determine the data and error columns for this relaxation data set. 3286 data_col = self.col['frq'] + i + 1 3287 error_col = self.col['frq'] + len(self.ri_labels) + i + 1 3288 3289 # Append the value and error. 3290 values.append(eval(self.file_line[data_col])) 3291 errors.append(eval(self.file_line[error_col])) 3292 3293 # Simulations. 3294 sim = 0 3295 if self.data_set != 'value' and self.data_set != 'error': 3296 sim = 1 3297 3298 # Add the relaxation data. 3299 self.relax.specific.relax_data.add_residue(run=self.run, res_index=self.res_index, ri_labels=self.ri_labels, remap_table=self.remap_table, frq_labels=self.frq_labels, frq=self.frq, values=values, errors=errors, sim=sim)

3300 3301

3302 - def read_columnar_results(self, run, file_data, print_flag=1):

3303 """Function for reading the results file.""" 3304 3305 # Arguments. 3306 self.run = run 3307 3308 # Extract and remove the header. 3309 header = file_data[0] 3310 file_data = file_data[1:] 3311 3312 # Sort the column numbers. 3313 self.read_columnar_col_numbers(header) 3314 3315 # Test the file. 3316 if len(self.col) < 2: 3317 raise RelaxInvalidDataError 3318 3319 # Initialise some data structures and flags. 3320 nucleus_set = 0 3321 sim_num = None 3322 sims = [] 3323 diff_data_set = 0 3324 diff_error_set = 0 3325 diff_sim_set = None 3326 self.param_set = None 3327 pdb = 0 3328 pdb_model = None 3329 pdb_heteronuc = None 3330 pdb_proton = None 3331 self.ri_labels = None 3332 3333 # Generate the sequence. 3334 for self.file_line in file_data: 3335 # The data set. 3336 self.data_set = self.file_line[self.col['data_set']] 3337 3338 # Stop creating the sequence once the data_set is no longer 'value'. 3339 if self.data_set != 'value': 3340 break 3341 3342 # Sequence. 3343 self.read_columnar_sequence() 3344 3345 3346 # Loop over the lines of the file data. 3347 for self.file_line in file_data: 3348 # The data set. 3349 self.data_set = self.file_line[self.col['data_set']] 3350 3351 # Find the residue index. 3352 self.res_index = self.read_columnar_find_index() 3353 3354 # Reassign data structure. 3355 data = self.relax.data.res[self.run][self.res_index] 3356 3357 # Skip unselected residues. 3358 if not data.select: 3359 continue 3360 3361 # Set the nucleus type. 3362 if not nucleus_set: 3363 if self.file_line[self.col['nucleus']] != 'None': 3364 self.relax.generic.nuclei.set_values(self.file_line[self.col['nucleus']]) 3365 nucleus_set = 1 3366 3367 # Simulation number. 3368 if self.data_set != 'value' and self.data_set != 'error': 3369 # Extract the number from the self.data_set string. 3370 sim_num = split(self.data_set, '_') 3371 try: 3372 sim_num = int(sim_num[1]) 3373 except: 3374 raise RelaxError, "The simulation number '%s' is invalid." % sim_num 3375 3376 # Update the sims array is sim_num is not in the array. 3377 if sim_num not in sims: 3378 sims.append(sim_num) 3379 3380 # Diffusion tensor data. 3381 if self.data_set == 'value' and not diff_data_set: 3382 self.read_columnar_diff_tensor() 3383 diff_data_set = 1 3384 3385 # Diffusion tensor errors. 3386 elif self.data_set == 'error' and not diff_error_set: 3387 self.read_columnar_diff_tensor() 3388 diff_error_set = 1 3389 3390 # Diffusion tensor simulation data. 3391 elif self.data_set != 'value' and self.data_set != 'error' and sim_num != diff_sim_set: 3392 self.read_columnar_diff_tensor() 3393 diff_sim_set = sim_num 3394 3395 # Parameter set. 3396 if self.param_set == None: 3397 self.read_columnar_param_set() 3398 3399 # PDB. 3400 if not pdb: 3401 if self.read_columnar_pdb(print_flag): 3402 pdb = 1 3403 3404 # XH vector. 3405 if self.data_set == 'value': 3406 self.read_columnar_xh_vect() 3407 3408 # Relaxation data. 3409 self.read_columnar_relax_data() 3410 3411 # Model-free data. 3412 self.read_columnar_model_free_data() 3413 3414 # Set up the simulations. 3415 if len(sims): 3416 self.relax.generic.monte_carlo.setup(self.run, len(sims))

3417 3418

3419 - def read_columnar_sequence(self):

3420 """Function for generating the sequence.""" 3421 3422 # Residue number and name. 3423 try: 3424 res_num = int(self.file_line[self.col['num']]) 3425 except ValueError: 3426 raise RelaxError, "The residue number " + self.file_line[self.col['num']] + " is not an integer." 3427 res_name = self.file_line[self.col['name']] 3428 3429 # Generate the sequence. 3430 self.relax.generic.sequence.add(self.run, res_num, res_name, select=int(self.file_line[self.col['select']]))

3431 3432

3433 - def read_columnar_xh_vect(self):

3434 """Function for reading the XH unit vectors.""" 3435 3436 # The vector. 3437 xh_vect = eval(self.file_line[self.col['xh_vect']]) 3438 if xh_vect: 3439 # Numeric array format. 3440 try: 3441 xh_vect = array(xh_vect, Float64) 3442 except: 3443 raise RelaxError, "The XH unit vector " + self.file_line[self.col['xh_vect']] + " is invalid." 3444 3445 # Set the vector. 3446 self.relax.generic.pdb.set_vector(run=self.run, res=self.res_index, xh_vect=xh_vect)

3447 3448

3449 - def remove_tm(self, run, res_num):

3450 """Function for removing the local tm parameter from the model-free parameters.""" 3451 3452 # Arguments. 3453 self.run = run 3454 3455 # Test if the run exists. 3456 if not self.run in self.relax.data.run_names: 3457 raise RelaxNoRunError, self.run 3458 3459 # Test if the run type is set to 'mf'. 3460 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 3461 if function_type != 'mf': 3462 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 3463 3464 # Test if sequence data is loaded. 3465 if not self.relax.data.res.has_key(self.run): 3466 raise RelaxNoSequenceError, self.run 3467 3468 # Loop over the sequence. 3469 for i in xrange(len(self.relax.data.res[self.run])): 3470 # Remap the data structure. 3471 data = self.relax.data.res[self.run][i] 3472 3473 # Skip unselected residues. 3474 if not data.select: 3475 continue 3476 3477 # If res_num is set, then skip all other residues. 3478 if res_num != None and res_num != data.num: 3479 continue 3480 3481 # Test if a local tm parameter exists. 3482 if not hasattr(data, 'params') or not 'tm' in data.params: 3483 continue 3484 3485 # Remove tm. 3486 data.params.remove('tm') 3487 3488 # Model name. 3489 if match('^tm', data.model): 3490 data.model = data.model[1:] 3491 3492 # Set the tm value to None. 3493 data.tm = None 3494 3495 # Set all the minimisation details to None. 3496 data.chi2 = None 3497 data.iter = None 3498 data.f_count = None 3499 data.g_count = None 3500 data.h_count = None 3501 data.warning = None 3502 3503 # Set the global minimisation details to None. 3504 self.relax.data.chi2[self.run] = None 3505 self.relax.data.iter[self.run] = None 3506 self.relax.data.f_count[self.run] = None 3507 self.relax.data.g_count[self.run] = None 3508 self.relax.data.h_count[self.run] = None 3509 self.relax.data.warning[self.run] = None

3510 3511

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

3513 """Function for returning the value and error corresponding to 'data_type'.""" 3514 3515 # Arguments. 3516 self.run = run 3517 3518 # Get the object. 3519 object_name = self.get_data_name(data_type) 3520 if not object_name: 3521 raise RelaxError, "The model-free data type " + `data_type` + " does not exist." 3522 object_error = object_name + "_err" 3523 3524 # Get the value. 3525 if hasattr(self.relax.data.res[self.run][i], object_name): 3526 value = getattr(self.relax.data.res[self.run][i], object_name) 3527 else: 3528 value = None 3529 3530 # Get the error. 3531 if hasattr(self.relax.data.res[self.run][i], object_error): 3532 error = getattr(self.relax.data.res[self.run][i], object_error) 3533 else: 3534 error = None 3535 3536 # Return the data. 3537 return value, error

3538 3539

3540 - def select_model(self, run=None, model=None, res_num=None):

3541 """Function for the selection of a preset model-free model.""" 3542 3543 # Arguments. 3544 self.run = run 3545 3546 # Test if the run exists. 3547 if not self.run in self.relax.data.run_names: 3548 raise RelaxNoRunError, self.run 3549 3550 # Test if the run type is set to 'mf'. 3551 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 3552 if function_type != 'mf': 3553 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 3554 3555 # Test if sequence data is loaded. 3556 if not self.relax.data.res.has_key(self.run): 3557 raise RelaxNoSequenceError, self.run 3558 3559 3560 # Preset models. 3561 ################ 3562 3563 # Block 1. 3564 if model == 'm0': 3565 equation = 'mf_orig' 3566 params = [] 3567 elif model == 'm1': 3568 equation = 'mf_orig' 3569 params = ['S2'] 3570 elif model == 'm2': 3571 equation = 'mf_orig' 3572 params = ['S2', 'te'] 3573 elif model == 'm3': 3574 equation = 'mf_orig' 3575 params = ['S2', 'Rex'] 3576 elif model == 'm4': 3577 equation = 'mf_orig' 3578 params = ['S2', 'te', 'Rex'] 3579 elif model == 'm5': 3580 equation = 'mf_ext' 3581 params = ['S2f', 'S2', 'ts'] 3582 elif model == 'm6': 3583 equation = 'mf_ext' 3584 params = ['S2f', 'tf', 'S2', 'ts'] 3585 elif model == 'm7': 3586 equation = 'mf_ext' 3587 params = ['S2f', 'S2', 'ts', 'Rex'] 3588 elif model == 'm8': 3589 equation = 'mf_ext' 3590 params = ['S2f', 'tf', 'S2', 'ts', 'Rex'] 3591 elif model == 'm9': 3592 equation = 'mf_orig' 3593 params = ['Rex'] 3594 3595 # Block 2. 3596 elif model == 'm10': 3597 equation = 'mf_orig' 3598 params = ['CSA'] 3599 elif model == 'm11': 3600 equation = 'mf_orig' 3601 params = ['CSA', 'S2'] 3602 elif model == 'm12': 3603 equation = 'mf_orig' 3604 params = ['CSA', 'S2', 'te'] 3605 elif model == 'm13': 3606 equation = 'mf_orig' 3607 params = ['CSA', 'S2', 'Rex'] 3608 elif model == 'm14': 3609 equation = 'mf_orig' 3610 params = ['CSA', 'S2', 'te', 'Rex'] 3611 elif model == 'm15': 3612 equation = 'mf_ext' 3613 params = ['CSA', 'S2f', 'S2', 'ts'] 3614 elif model == 'm16': 3615 equation = 'mf_ext' 3616 params = ['CSA', 'S2f', 'tf', 'S2', 'ts'] 3617 elif model == 'm17': 3618 equation = 'mf_ext' 3619 params = ['CSA', 'S2f', 'S2', 'ts', 'Rex'] 3620 elif model == 'm18': 3621 equation = 'mf_ext' 3622 params = ['CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3623 elif model == 'm19': 3624 equation = 'mf_orig' 3625 params = ['CSA', 'Rex'] 3626 3627 # Block 3. 3628 elif model == 'm20': 3629 equation = 'mf_orig' 3630 params = ['r'] 3631 elif model == 'm21': 3632 equation = 'mf_orig' 3633 params = ['r', 'S2'] 3634 elif model == 'm22': 3635 equation = 'mf_orig' 3636 params = ['r', 'S2', 'te'] 3637 elif model == 'm23': 3638 equation = 'mf_orig' 3639 params = ['r', 'S2', 'Rex'] 3640 elif model == 'm24': 3641 equation = 'mf_orig' 3642 params = ['r', 'S2', 'te', 'Rex'] 3643 elif model == 'm25': 3644 equation = 'mf_ext' 3645 params = ['r', 'S2f', 'S2', 'ts'] 3646 elif model == 'm26': 3647 equation = 'mf_ext' 3648 params = ['r', 'S2f', 'tf', 'S2', 'ts'] 3649 elif model == 'm27': 3650 equation = 'mf_ext' 3651 params = ['r', 'S2f', 'S2', 'ts', 'Rex'] 3652 elif model == 'm28': 3653 equation = 'mf_ext' 3654 params = ['r', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3655 elif model == 'm29': 3656 equation = 'mf_orig' 3657 params = ['r', 'Rex'] 3658 3659 # Block 4. 3660 elif model == 'm30': 3661 equation = 'mf_orig' 3662 params = ['r', 'CSA'] 3663 elif model == 'm31': 3664 equation = 'mf_orig' 3665 params = ['r', 'CSA', 'S2'] 3666 elif model == 'm32': 3667 equation = 'mf_orig' 3668 params = ['r', 'CSA', 'S2', 'te'] 3669 elif model == 'm33': 3670 equation = 'mf_orig' 3671 params = ['r', 'CSA', 'S2', 'Rex'] 3672 elif model == 'm34': 3673 equation = 'mf_orig' 3674 params = ['r', 'CSA', 'S2', 'te', 'Rex'] 3675 elif model == 'm35': 3676 equation = 'mf_ext' 3677 params = ['r', 'CSA', 'S2f', 'S2', 'ts'] 3678 elif model == 'm36': 3679 equation = 'mf_ext' 3680 params = ['r', 'CSA', 'S2f', 'tf', 'S2', 'ts'] 3681 elif model == 'm37': 3682 equation = 'mf_ext' 3683 params = ['r', 'CSA', 'S2f', 'S2', 'ts', 'Rex'] 3684 elif model == 'm38': 3685 equation = 'mf_ext' 3686 params = ['r', 'CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3687 elif model == 'm39': 3688 equation = 'mf_orig' 3689 params = ['r', 'CSA', 'Rex'] 3690 3691 3692 # Preset models with local correlation time. 3693 ############################################ 3694 3695 # Block 1. 3696 elif model == 'tm0': 3697 equation = 'mf_orig' 3698 params = ['tm'] 3699 elif model == 'tm1': 3700 equation = 'mf_orig' 3701 params = ['tm', 'S2'] 3702 elif model == 'tm2': 3703 equation = 'mf_orig' 3704 params = ['tm', 'S2', 'te'] 3705 elif model == 'tm3': 3706 equation = 'mf_orig' 3707 params = ['tm', 'S2', 'Rex'] 3708 elif model == 'tm4': 3709 equation = 'mf_orig' 3710 params = ['tm', 'S2', 'te', 'Rex'] 3711 elif model == 'tm5': 3712 equation = 'mf_ext' 3713 params = ['tm', 'S2f', 'S2', 'ts'] 3714 elif model == 'tm6': 3715 equation = 'mf_ext' 3716 params = ['tm', 'S2f', 'tf', 'S2', 'ts'] 3717 elif model == 'tm7': 3718 equation = 'mf_ext' 3719 params = ['tm', 'S2f', 'S2', 'ts', 'Rex'] 3720 elif model == 'tm8': 3721 equation = 'mf_ext' 3722 params = ['tm', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3723 elif model == 'tm9': 3724 equation = 'mf_orig' 3725 params = ['tm', 'Rex'] 3726 3727 # Block 2. 3728 elif model == 'tm10': 3729 equation = 'mf_orig' 3730 params = ['tm', 'CSA'] 3731 elif model == 'tm11': 3732 equation = 'mf_orig' 3733 params = ['tm', 'CSA', 'S2'] 3734 elif model == 'tm12': 3735 equation = 'mf_orig' 3736 params = ['tm', 'CSA', 'S2', 'te'] 3737 elif model == 'tm13': 3738 equation = 'mf_orig' 3739 params = ['tm', 'CSA', 'S2', 'Rex'] 3740 elif model == 'tm14': 3741 equation = 'mf_orig' 3742 params = ['tm', 'CSA', 'S2', 'te', 'Rex'] 3743 elif model == 'tm15': 3744 equation = 'mf_ext' 3745 params = ['tm', 'CSA', 'S2f', 'S2', 'ts'] 3746 elif model == 'tm16': 3747 equation = 'mf_ext' 3748 params = ['tm', 'CSA', 'S2f', 'tf', 'S2', 'ts'] 3749 elif model == 'tm17': 3750 equation = 'mf_ext' 3751 params = ['tm', 'CSA', 'S2f', 'S2', 'ts', 'Rex'] 3752 elif model == 'tm18': 3753 equation = 'mf_ext' 3754 params = ['tm', 'CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3755 elif model == 'tm19': 3756 equation = 'mf_orig' 3757 params = ['tm', 'CSA', 'Rex'] 3758 3759 # Block 3. 3760 elif model == 'tm20': 3761 equation = 'mf_orig' 3762 params = ['tm', 'r'] 3763 elif model == 'tm21': 3764 equation = 'mf_orig' 3765 params = ['tm', 'r', 'S2'] 3766 elif model == 'tm22': 3767 equation = 'mf_orig' 3768 params = ['tm', 'r', 'S2', 'te'] 3769 elif model == 'tm23': 3770 equation = 'mf_orig' 3771 params = ['tm', 'r', 'S2', 'Rex'] 3772 elif model == 'tm24': 3773 equation = 'mf_orig' 3774 params = ['tm', 'r', 'S2', 'te', 'Rex'] 3775 elif model == 'tm25': 3776 equation = 'mf_ext' 3777 params = ['tm', 'r', 'S2f', 'S2', 'ts'] 3778 elif model == 'tm26': 3779 equation = 'mf_ext' 3780 params = ['tm', 'r', 'S2f', 'tf', 'S2', 'ts'] 3781 elif model == 'tm27': 3782 equation = 'mf_ext' 3783 params = ['tm', 'r', 'S2f', 'S2', 'ts', 'Rex'] 3784 elif model == 'tm28': 3785 equation = 'mf_ext' 3786 params = ['tm', 'r', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3787 elif model == 'tm29': 3788 equation = 'mf_orig' 3789 params = ['tm', 'r', 'Rex'] 3790 3791 # Block 4. 3792 elif model == 'tm30': 3793 equation = 'mf_orig' 3794 params = ['tm', 'r', 'CSA'] 3795 elif model == 'tm31': 3796 equation = 'mf_orig' 3797 params = ['tm', 'r', 'CSA', 'S2'] 3798 elif model == 'tm32': 3799 equation = 'mf_orig' 3800 params = ['tm', 'r', 'CSA', 'S2', 'te'] 3801 elif model == 'tm33': 3802 equation = 'mf_orig' 3803 params = ['tm', 'r', 'CSA', 'S2', 'Rex'] 3804 elif model == 'tm34': 3805 equation = 'mf_orig' 3806 params = ['tm', 'r', 'CSA', 'S2', 'te', 'Rex'] 3807 elif model == 'tm35': 3808 equation = 'mf_ext' 3809 params = ['tm', 'r', 'CSA', 'S2f', 'S2', 'ts'] 3810 elif model == 'tm36': 3811 equation = 'mf_ext' 3812 params = ['tm', 'r', 'CSA', 'S2f', 'tf', 'S2', 'ts'] 3813 elif model == 'tm37': 3814 equation = 'mf_ext' 3815 params = ['tm', 'r', 'CSA', 'S2f', 'S2', 'ts', 'Rex'] 3816 elif model == 'tm38': 3817 equation = 'mf_ext' 3818 params = ['tm', 'r', 'CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3819 elif model == 'tm39': 3820 equation = 'mf_orig' 3821 params = ['tm', 'r', 'CSA', 'Rex'] 3822 3823 # Invalid models. 3824 else: 3825 raise RelaxError, "The model '" + model + "' is invalid." 3826 3827 # Set up the model. 3828 self.model_setup(self.run, model, equation, params, res_num)

3829 3830

3831 - def set(self, run=None, value=None, error=None, data_type=None, index=None):

3832 """ 3833 Model-free set details 3834 ~~~~~~~~~~~~~~~~~~~~~~ 3835 3836 Setting a parameter value may have no effect depending on which model-free model is chosen, 3837 for example if S2f values and S2s values are set but the run corresponds to model-free model 3838 'm4' then, because these data values are not parameters of the model, they will have no 3839 effect. 3840 3841 Note that the Rex values are scaled quadratically with field strength and should be supplied 3842 as a field strength independent value. Use the following formula to get the correct value: 3843 3844 value = Rex / (2.0 * pi * frequency) ** 2 3845 3846 where: 3847 Rex is the chemical exchange value for the current frequency. 3848 pi is in the namespace of relax, ie just type 'pi'. 3849 frequency is the proton frequency corresponding to the data. 3850 """ 3851 3852 # Arguments. 3853 self.run = run 3854 3855 # Setting the model parameters prior to minimisation. 3856 ##################################################### 3857 3858 if data_type == None: 3859 # The values are supplied by the user: 3860 if value: 3861 # Test if the length of the value array is equal to the length of the model-free parameter array. 3862 if len(value) != len(self.relax.data.res[self.run][index].params): 3863 raise RelaxError, "The length of " + `len(value)` + " of the value array must be equal to the length of the model-free parameter array, " + `self.relax.data.res[self.run][index].params` + ", for residue " + `self.relax.data.res[self.run][index].num` + " " + self.relax.data.res[self.run][index].name + "." 3864 3865 # Default values. 3866 else: 3867 # Set 'value' to an empty array. 3868 value = [] 3869 3870 # Loop over the model-free parameters. 3871 for i in xrange(len(self.relax.data.res[self.run][index].params)): 3872 value.append(self.default_value(self.relax.data.res[self.run][index].params[i])) 3873 3874 # Loop over the model-free parameters. 3875 for i in xrange(len(self.relax.data.res[self.run][index].params)): 3876 # Get the object. 3877 object_name = self.get_data_name(self.relax.data.res[self.run][index].params[i]) 3878 if not object_name: 3879 raise RelaxError, "The model-free data type " + `self.relax.data.res[self.run][index].params[i]` + " does not exist." 3880 3881 # Initialise all data if it doesn't exist. 3882 if not hasattr(self.relax.data.res[self.run][index], object_name): 3883 self.initialise_data(self.relax.data.res[self.run][index], self.run) 3884 3885 # Set the value. 3886 setattr(self.relax.data.res[self.run][index], object_name, float(value[i])) 3887 3888 3889 # Individual data type. 3890 ####################### 3891 3892 else: 3893 # Get the object. 3894 object_name = self.get_data_name(data_type) 3895 if not object_name: 3896 raise RelaxError, "The model-free data type " + `data_type` + " does not exist." 3897 3898 # Initialise all data if it doesn't exist. 3899 if not hasattr(self.relax.data.res[self.run][index], object_name): 3900 self.initialise_data(self.relax.data.res[self.run][index], self.run) 3901 3902 # Default value. 3903 if value == None: 3904 value = self.default_value(object_name) 3905 3906 # Set the value. 3907 setattr(self.relax.data.res[self.run][index], object_name, float(value)) 3908 3909 # Set the error. 3910 if error != None: 3911 setattr(self.relax.data.res[self.run][index], object_name+'_error', float(error))

3912 3913

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

3915 """Function for setting parameter errors.""" 3916 3917 # Arguments. 3918 self.run = run 3919 3920 # Increment counter for the parameter set 'all'. 3921 inc = 0 3922 3923 # Get the parameter object names. 3924 param_names = self.data_names(set='params') 3925 3926 3927 # Diffusion tensor parameter errors. 3928 #################################### 3929 3930 if self.param_set == 'diff' or self.param_set == 'all': 3931 # Isotropic diffusion. 3932 if self.relax.data.diff[self.run].type == 'iso': 3933 # Return the parameter array. 3934 if index == 0: 3935 self.relax.data.diff[self.run].tm_err = error 3936 3937 # Increment. 3938 inc = inc + 1 3939 3940 # Axially symmetric diffusion. 3941 elif self.relax.data.diff[self.run].type == 'axial': 3942 # Return the parameter array. 3943 if index == 0: 3944 self.relax.data.diff[self.run].tm_err = error 3945 elif index == 1: 3946 self.relax.data.diff[self.run].Da_err = error 3947 elif index == 2: 3948 self.relax.data.diff[self.run].theta_err = error 3949 elif index == 3: 3950 self.relax.data.diff[self.run].phi_err = error 3951 3952 # Increment. 3953 inc = inc + 4 3954 3955 # Anisotropic diffusion. 3956 elif self.relax.data.diff[self.run].type == 'aniso': 3957 # Return the parameter array. 3958 if index == 0: 3959 self.relax.data.diff[self.run].tm_err = error 3960 elif index == 1: 3961 self.relax.data.diff[self.run].Da_err = error 3962 elif index == 2: 3963 self.relax.data.diff[self.run].Dr_err = error 3964 elif index == 3: 3965 self.relax.data.diff[self.run].alpha_err = error 3966 elif index == 4: 3967 self.relax.data.diff[self.run].beta_err = error 3968 elif index == 5: 3969 self.relax.data.diff[self.run].gamma_err = error 3970 3971 # Increment. 3972 inc = inc + 6 3973 3974 3975 # Model-free parameter errors for the parameter set 'all'. 3976 ########################################################## 3977 3978 if self.param_set == 'all': 3979 # Loop over the sequence. 3980 for i in xrange(len(self.relax.data.res[self.run])): 3981 # Skip unselected residues. 3982 if not self.relax.data.res[self.run][i].select: 3983 continue 3984 3985 # Loop over the residue specific parameters. 3986 for param in param_names: 3987 # Return the parameter array. 3988 if index == inc: 3989 setattr(self.relax.data.res[self.run][i], param + "_err", error) 3990 3991 # Increment. 3992 inc = inc + 1 3993 3994 3995 # Model-free parameters for the parameter sets 'mf' and 'local_tm'. 3996 ################################################################### 3997 3998 if self.param_set == 'mf' or self.param_set == 'local_tm': 3999 # Skip unselected residues. 4000 if not self.relax.data.res[self.run][instance].select: 4001 return 4002 4003 # Loop over the residue specific parameters. 4004 for param in param_names: 4005 # Return the parameter array. 4006 if index == inc: 4007 setattr(self.relax.data.res[self.run][instance], param + "_err", error) 4008 4009 # Increment. 4010 inc = inc + 1

4011 4012

4013 - def sim_init_values(self, run):

4014 """Function for initialising Monte Carlo parameter values.""" 4015 4016 # Arguments. 4017 self.run = run 4018 4019 # Determine the parameter set type. 4020 self.param_set = self.determine_param_set_type() 4021 4022 # Get the parameter object names. 4023 param_names = self.data_names(set='params') 4024 4025 # Get the minimisation statistic object names. 4026 min_names = self.data_names(set='min') 4027 4028 # List of diffusion tensor parameters. 4029 if self.param_set == 'diff' or self.param_set == 'all': 4030 # Isotropic diffusion. 4031 if self.relax.data.diff[self.run].type == 'iso': 4032 diff_params = ['tm'] 4033 4034 # Axially symmetric diffusion. 4035 elif self.relax.data.diff[self.run].type == 'axial': 4036 diff_params = ['tm', 'Da', 'theta', 'phi'] 4037 4038 # Anisotropic diffusion. 4039 elif self.relax.data.diff[self.run].type == 'aniso': 4040 diff_params = ['tm', 'Da', 'Dr', 'alpha', 'beta', 'gamma'] 4041 4042 4043 # Test if Monte Carlo parameter values have already been set. 4044 ############################################################# 4045 4046 # Diffusion tensor parameters and non residue specific minimisation statistics. 4047 if self.param_set == 'diff' or self.param_set == 'all': 4048 # Loop over the parameters. 4049 for object_name in diff_params: 4050 # Name for the simulation object. 4051 sim_object_name = object_name + '_sim' 4052 4053 # Test if the simulation object already exists. 4054 if hasattr(self.relax.data.diff[self.run], sim_object_name): 4055 raise RelaxError, "Monte Carlo parameter values have already been set." 4056 4057 # Loop over the minimisation stats objects. 4058 for object_name in min_names: 4059 # Name for the simulation object. 4060 sim_object_name = object_name + '_sim' 4061 4062 # Test if the simulation object already exists. 4063 if hasattr(self.relax.data, sim_object_name): 4064 raise RelaxError, "Monte Carlo parameter values have already been set." 4065 4066 # Residue specific parameters. 4067 if self.param_set != 'diff': 4068 for i in xrange(len(self.relax.data.res[self.run])): 4069 # Skip unselected residues. 4070 if not self.relax.data.res[self.run][i].select: 4071 continue 4072 4073 # Loop over all the parameter names. 4074 for object_name in param_names: 4075 # Name for the simulation object. 4076 sim_object_name = object_name + '_sim' 4077 4078 # Test if the simulation object already exists. 4079 if hasattr(self.relax.data.res[self.run][i], sim_object_name): 4080 raise RelaxError, "Monte Carlo parameter values have already been set." 4081 4082 4083 # Set the Monte Carlo parameter values. 4084 ####################################### 4085 4086 # Loop over the global minimisation stats objects. 4087 for object_name in min_names: 4088 # Name for the simulation object. 4089 sim_object_name = object_name + '_sim' 4090 4091 # Create the simulation object. 4092 setattr(self.relax.data, sim_object_name, {}) 4093 4094 # Get the simulation object. 4095 sim_object = getattr(self.relax.data, sim_object_name) 4096 4097 # Add the run. 4098 sim_object[self.run] = [] 4099 4100 # Loop over the simulations. 4101 for j in xrange(self.relax.data.sim_number[self.run]): 4102 # Get the object. 4103 object = getattr(self.relax.data, object_name) 4104 4105 # Test if the object has the key self.run. 4106 if not object.has_key(self.relax): 4107 continue 4108 4109 # Copy and append the data. 4110 sim_object[self.run].append(deepcopy(object[self.run])) 4111 4112 # Diffusion tensor parameters and non residue specific minimisation statistics. 4113 if self.param_set == 'diff' or self.param_set == 'all': 4114 # Loop over the parameters. 4115 for object_name in diff_params: 4116 # Name for the simulation object. 4117 sim_object_name = object_name + '_sim' 4118 4119 # Create the simulation object. 4120 setattr(self.relax.data.diff[self.run], sim_object_name, []) 4121 4122 # Get the simulation object. 4123 sim_object = getattr(self.relax.data.diff[self.run], sim_object_name) 4124 4125 # Loop over the simulations. 4126 for j in xrange(self.relax.data.sim_number[self.run]): 4127 # Copy and append the data. 4128 sim_object.append(deepcopy(getattr(self.relax.data.diff[self.run], object_name))) 4129 4130 # Residue specific parameters. 4131 if self.param_set != 'diff': 4132 for i in xrange(len(self.relax.data.res[self.run])): 4133 # Skip unselected residues. 4134 if not self.relax.data.res[self.run][i].select: 4135 continue 4136 4137 # Loop over all the data names. 4138 for object_name in param_names: 4139 # Name for the simulation object. 4140 sim_object_name = object_name + '_sim' 4141 4142 # Create the simulation object. 4143 setattr(self.relax.data.res[self.run][i], sim_object_name, []) 4144 4145 # Get the simulation object. 4146 sim_object = getattr(self.relax.data.res[self.run][i], sim_object_name) 4147 4148 # Loop over the simulations. 4149 for j in xrange(self.relax.data.sim_number[self.run]): 4150 # Copy and append the data. 4151 sim_object.append(deepcopy(getattr(self.relax.data.res[self.run][i], object_name))) 4152 4153 # Loop over all the minimisation object names. 4154 for object_name in min_names: 4155 # Name for the simulation object. 4156 sim_object_name = object_name + '_sim' 4157 4158 # Create the simulation object. 4159 setattr(self.relax.data.res[self.run][i], sim_object_name, []) 4160 4161 # Get the simulation object. 4162 sim_object = getattr(self.relax.data.res[self.run][i], sim_object_name) 4163 4164 # Loop over the simulations. 4165 for j in xrange(self.relax.data.sim_number[self.run]): 4166 # Copy and append the data. 4167 sim_object.append(deepcopy(getattr(self.relax.data.res[self.run][i], object_name)))

4168 4169

4170 - def sim_return_chi2(self, run, instance):

4171 """Function for returning the array of simulation chi-squared values.""" 4172 4173 # Arguments. 4174 self.run = run 4175 4176 # Determine the parameter set type. 4177 self.param_set = self.determine_param_set_type() 4178 4179 # Single instance. 4180 if self.param_set == 'all' or self.param_set == 'diff': 4181 return self.relax.data.chi2_sim[self.run] 4182 4183 # Multiple instances. 4184 else: 4185 return self.relax.data.res[self.run][instance].chi2_sim

4186 4187

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

4189 """Function for returning the array of simulation parameter values.""" 4190 4191 # Arguments. 4192 self.run = run 4193 4194 # Increment counter for the parameter set 'all'. 4195 inc = 0 4196 4197 # Get the parameter object names. 4198 param_names = self.data_names(set='params') 4199 4200 4201 # Diffusion tensor parameters. 4202 ############################## 4203 4204 if self.param_set == 'diff' or self.param_set == 'all': 4205 # Isotropic diffusion. 4206 if self.relax.data.diff[self.run].type == 'iso': 4207 # Return the parameter array. 4208 if index == 0: 4209 return self.relax.data.diff[self.run].tm_sim 4210 4211 # Increment. 4212 inc = inc + 1 4213 4214 # Axially symmetric diffusion. 4215 elif self.relax.data.diff[self.run].type == 'axial': 4216 # Return the parameter array. 4217 if index == 0: 4218 return self.relax.data.diff[self.run].tm_sim 4219 elif index == 1: 4220 return self.relax.data.diff[self.run].Da_sim 4221 elif index == 2: 4222 return self.relax.data.diff[self.run].theta_sim 4223 elif index == 3: 4224 return self.relax.data.diff[self.run].phi_sim 4225 4226 # Increment. 4227 inc = inc + 4 4228 4229 # Anisotropic diffusion. 4230 elif self.relax.data.diff[self.run].type == 'aniso': 4231 # Return the parameter array. 4232 if index == 0: 4233 return self.relax.data.diff[self.run].tm_sim 4234 elif index == 1: 4235 return self.relax.data.diff[self.run].Da_sim 4236 elif index == 2: 4237 return self.relax.data.diff[self.run].Dr_sim 4238 elif index == 3: 4239 return self.relax.data.diff[self.run].alpha_sim 4240 elif index == 4: 4241 return self.relax.data.diff[self.run].beta_sim 4242 elif index == 5: 4243 return self.relax.data.diff[self.run].gamma_sim 4244 4245 # Increment. 4246 inc = inc + 6 4247 4248 4249 # Model-free parameters for the parameter set 'all'. 4250 #################################################### 4251 4252 if self.param_set == 'all': 4253 # Loop over the sequence. 4254 for i in xrange(len(self.relax.data.res[self.run])): 4255 # Skip unselected residues. 4256 if not self.relax.data.res[self.run][i].select: 4257 continue 4258 4259 # Loop over the residue specific parameters. 4260 for param in param_names: 4261 # Return the parameter array. 4262 if index == inc: 4263 return getattr(self.relax.data.res[self.run][i], param + "_sim") 4264 4265 # Increment. 4266 inc = inc + 1 4267 4268 4269 # Model-free parameters for the parameter sets 'mf' and 'local_tm'. 4270 ################################################################### 4271 4272 if self.param_set == 'mf' or self.param_set == 'local_tm': 4273 # Skip unselected residues. 4274 if not self.relax.data.res[self.run][instance].select: 4275 return 4276 4277 # Loop over the residue specific parameters. 4278 for param in param_names: 4279 # Return the parameter array. 4280 if index == inc: 4281 return getattr(self.relax.data.res[self.run][instance], param + "_sim") 4282 4283 # Increment. 4284 inc = inc + 1

4285 4286

4287 - def skip_function(self, run=None, instance=None, min_instances=None, num_instances=None):

4288 """Function for skiping certain data.""" 4289 4290 # Arguments. 4291 self.run = run 4292 4293 # Determine the parameter set type. 4294 self.param_set = self.determine_param_set_type() 4295 4296 # Consolidate the instances to the minimum number. 4297 consolidate = 0 4298 if min_instances == 1 and min_instances != num_instances: 4299 consolidate = 1 4300 4301 # Sequence specific data. 4302 if (self.param_set == 'mf' or self.param_set == 'local_tm') and not consolidate and not self.relax.data.res[self.run][instance].select: 4303 return 1 4304 4305 # Don't skip. 4306 return 0

4307 4308

4309 - def unselect(self, run, i):

4310 """Function for unselecting models.""" 4311 4312 # Arguments. 4313 self.run = run 4314 4315 # Determine the parameter set type. 4316 self.param_set = self.determine_param_set_type() 4317 4318 # Single residue. 4319 if self.param_set == 'mf' or self.param_set == 'local_tm': 4320 self.relax.data.res[self.run][i].select = 0

4321 4322

4323 - def write_columnar_line(self, file=None, num=None, name=None, select=None, data_set=None, nucleus=None, model=None, equation=None, params=None, param_set=None, s2=None, s2f=None, s2s=None, local_tm=None, te=None, tf=None, ts=None, rex=None, r=None, csa=None, chi2=None, i=None, f=None, g=None, h=None, warn=None, diff_type=None, diff_params=None, pdb=None, pdb_model=None, pdb_heteronuc=None, pdb_proton=None, xh_vect=None, ri_labels=None, remap_table=None, frq_labels=None, frq=None, ri=None, ri_error=None):

4324 """Function for printing a single line of the columnar formatted results.""" 4325 4326 # Residue number and name. 4327 file.write("%-4s %-5s " % (num, name)) 4328 4329 # Selected flag and data set. 4330 file.write("%-9s %-9s " % (select, data_set)) 4331 if not select: 4332 file.write("\n") 4333 return 4334 4335 # Nucleus. 4336 file.write("%-7s " % nucleus) 4337 4338 # Model details. 4339 file.write("%-5s %-9s %-35s " % (model, equation, params)) 4340 4341 # Parameter set. 4342 file.write("%-10s " % param_set) 4343 4344 # Parameters. 4345 file.write("%-25s " % s2) 4346 file.write("%-25s " % s2f) 4347 file.write("%-25s " % s2s) 4348 file.write("%-25s " % local_tm) 4349 file.write("%-25s " % te) 4350 file.write("%-25s " % tf) 4351 file.write("%-25s " % ts) 4352 file.write("%-25s " % rex) 4353 file.write("%-25s " % r) 4354 file.write("%-25s " % csa) 4355 4356 # Minimisation results. 4357 file.write("%-25s %-8s %-8s %-8s %-8s %-45s " % (chi2, i, f, g, h, warn)) 4358 4359 # Diffusion parameters. 4360 file.write("%-10s " % diff_type) 4361 if diff_params: 4362 for i in xrange(len(diff_params)): 4363 file.write("%-25s " % diff_params[i]) 4364 4365 # PDB. 4366 file.write("%-40s " % pdb) 4367 file.write("%-10s " % pdb_model) 4368 file.write("%-15s " % pdb_heteronuc) 4369 file.write("%-15s " % pdb_proton) 4370 4371 # XH unit vector. 4372 file.write("%-70s " % xh_vect) 4373 4374 # Relaxation data setup. 4375 if ri_labels: 4376 file.write("%-40s " % ri_labels) 4377 file.write("%-25s " % remap_table) 4378 file.write("%-25s " % frq_labels) 4379 file.write("%-30s " % frq) 4380 4381 # Relaxation data. 4382 if ri: 4383 for i in xrange(len(ri)): 4384 if ri[i] == None: 4385 file.write("%-25s " % 'None') 4386 else: 4387 file.write("%-25s " % ri[i]) 4388 4389 # Relaxation errors. 4390 if ri_error: 4391 for i in xrange(len(ri_error)): 4392 if ri_error[i] == None: 4393 file.write("%-25s " % 'None') 4394 else: 4395 file.write("%-25s " % ri_error[i]) 4396 4397 # End of the line. 4398 file.write("\n")

4399 4400

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

4402 """Function for printing the results into a file.""" 4403 4404 # Arguments. 4405 self.run = run 4406 4407 # Determine the parameter set type. 4408 self.param_set = self.determine_param_set_type() 4409 4410 4411 # Header. 4412 ######### 4413 4414 # Diffusion parameters. 4415 diff_params = None 4416 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run): 4417 # Isotropic. 4418 if self.relax.data.diff[self.run].type == 'iso': 4419 diff_params = ['tm_(s)'] 4420 4421 # Axially symmetric. 4422 elif self.relax.data.diff[self.run].type == 'axial': 4423 diff_params = ['tm_(s)', 'Da_(1/s)', 'theta_(deg)', 'phi_(deg)'] 4424 4425 # Anisotropic. 4426 elif self.relax.data.diff[self.run].type == 'aniso': 4427 diff_params = ['tm_(s)', 'Da_(1/s)', 'Dr_(1/s)', 'alpha_(deg)', 'beta_(deg)', 'gamma_(deg)'] 4428 4429 # Relaxation data and errors. 4430 ri = [] 4431 ri_error = [] 4432 if hasattr(self.relax.data, 'num_ri'): 4433 for i in xrange(self.relax.data.num_ri[self.run]): 4434 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]] + ")") 4435 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]] + ")") 4436 4437 # Write the header line. 4438 self.write_columnar_line(file=file, num='Num', name='Name', select='Selected', data_set='Data_set', nucleus='Nucleus', model='Model', equation='Equation', params='Params', param_set='Param_set', s2='S2', s2f='S2f', s2s='S2s', local_tm='Local_tm_(ns)', te='te_(ps)', tf='tf_(ps)', ts='ts_(ps)', rex='Rex_(1st_field)', r='Bond_length_(A)', csa='CSA_(ppm)', chi2='Chi-squared', i='Iter', f='f_count', g='g_count', h='h_count', warn='Warning', diff_type='Diff_type', diff_params=diff_params, pdb='PDB', pdb_model='PDB_model', pdb_heteronuc='PDB_heteronuc', pdb_proton='PDB_proton', xh_vect='XH_vector', ri_labels='Ri_labels', remap_table='Remap_table', frq_labels='Frq_labels', frq='Frequencies', ri=ri, ri_error=ri_error) 4439 4440 4441 # Values. 4442 ######### 4443 4444 # Nucleus. 4445 nucleus = self.relax.generic.nuclei.find_nucleus() 4446 4447 # Diffusion parameters. 4448 diff_type = None 4449 diff_params = None 4450 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run): 4451 # Isotropic. 4452 if self.relax.data.diff[self.run].type == 'iso': 4453 diff_type = 'iso' 4454 diff_params = [`self.relax.data.diff[self.run].tm`] 4455 4456 # Axially symmetric. 4457 elif self.relax.data.diff[self.run].type == 'axial': 4458 diff_type = self.relax.data.diff[self.run].axial_type 4459 if diff_type == None: 4460 diff_type = 'axial' 4461 diff_params = [`self.relax.data.diff[self.run].tm`, `self.relax.data.diff[self.run].Da`, `self.relax.data.diff[self.run].theta * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].phi * 360 / (2.0 * pi)`] 4462 4463 # Anisotropic. 4464 elif self.relax.data.diff[self.run].type == 'aniso': 4465 diff_type = 'aniso' 4466 diff_params = [`self.relax.data.diff[self.run].tm`, `self.relax.data.diff[self.run].Da`, `self.relax.data.diff[self.run].Dr`, `self.relax.data.diff[self.run].alpha * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].beta * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].gamma * 360 / (2.0 * pi)`] 4467 4468 # PDB. 4469 pdb = None 4470 pdb_model = None 4471 pdb_heteronuc = None 4472 pdb_proton = None 4473 if self.relax.data.pdb.has_key(self.run): 4474 pdb = self.relax.data.pdb[self.run].file_name 4475 pdb_model = self.relax.data.pdb[self.run].model 4476 pdb_heteronuc = self.relax.data.pdb[self.run].heteronuc 4477 pdb_proton = self.relax.data.pdb[self.run].proton 4478 4479 # Relaxation data setup. 4480 try: 4481 ri_labels = replace(`self.relax.data.ri_labels[self.run]`, ' ', '') 4482 remap_table = replace(`self.relax.data.remap_table[self.run]`, ' ', '') 4483 frq_labels = replace(`self.relax.data.frq_labels[self.run]`, ' ', '') 4484 frq = replace(`self.relax.data.frq[self.run]`, ' ', '') 4485 except AttributeError: 4486 ri_labels = `None` 4487 remap_table = `None` 4488 frq_labels = `None` 4489 frq = `None` 4490 4491 # Loop over the sequence. 4492 for i in xrange(len(self.relax.data.res[self.run])): 4493 # Reassign data structure. 4494 data = self.relax.data.res[self.run][i] 4495 4496 # Unselected residues. 4497 if not data.select: 4498 self.write_columnar_line(file=file, num=data.num, name=data.name, select=0, data_set='value') 4499 continue 4500 4501 # Model details. 4502 model = None 4503 if hasattr(data, 'model'): 4504 model = data.model 4505 4506 equation = None 4507 if hasattr(data, 'equation'): 4508 equation = data.equation 4509 4510 params = None 4511 if hasattr(data, 'params'): 4512 params = replace(`data.params`, ' ', '') 4513 4514 # S2. 4515 s2 = None 4516 if hasattr(data, 's2'): 4517 s2 = data.s2 4518 4519 # S2f. 4520 s2f = None 4521 if hasattr(data, 's2f'): 4522 s2f = data.s2f 4523 4524 # S2s. 4525 s2s = None 4526 if hasattr(data, 's2s'): 4527 s2s = data.s2s 4528 4529 # tm. 4530 local_tm = None 4531 if hasattr(data, 'tm') and data.tm != None: 4532 local_tm = data.tm / 1e-9 4533 4534 # te. 4535 te = None 4536 if hasattr(data, 'te') and data.te != None: 4537 te = data.te / 1e-12 4538 4539 # tf. 4540 tf = None 4541 if hasattr(data, 'tf') and data.tf != None: 4542 tf = data.tf / 1e-12 4543 4544 # ts. 4545 ts = None 4546 if hasattr(data, 'ts') and data.ts != None: 4547 ts = data.ts / 1e-12 4548 4549 # Rex. 4550 rex = None 4551 if hasattr(data, 'rex') and data.rex != None: 4552 rex = data.rex * (2.0 * pi * data.frq[0])**2 4553 4554 # Bond length. 4555 r = None 4556 if hasattr(data, 'r') and data.r != None: 4557 r = data.r / 1e-10 4558 4559 # CSA. 4560 csa = None 4561 if hasattr(data, 'csa') and data.csa != None: 4562 csa = data.csa / 1e-6 4563 4564 # Minimisation details. 4565 try: 4566 # Global minimisation results. 4567 if self.param_set == 'diff' or self.param_set == 'all': 4568 chi2 = self.relax.data.chi2[self.run] 4569 iter = self.relax.data.iter[self.run] 4570 f = self.relax.data.f_count[self.run] 4571 g = self.relax.data.g_count[self.run] 4572 h = self.relax.data.h_count[self.run] 4573 if type(self.relax.data.warning[self.run]) == str: 4574 warn = replace(self.relax.data.warning[self.run], ' ', '_') 4575 else: 4576 warn = self.relax.data.warning[self.run] 4577 4578 # Individual residue results. 4579 else: 4580 chi2 = data.chi2 4581 iter = data.iter 4582 f = data.f_count 4583 g = data.g_count 4584 h = data.h_count 4585 if type(data.warning) == str: 4586 warn = replace(data.warning, ' ', '_') 4587 else: 4588 warn = data.warning 4589 4590 # No minimisation details. 4591 except: 4592 chi2 = None 4593 iter = None 4594 f = None 4595 g = None 4596 h = None 4597 warn = None 4598 4599 # XH vector. 4600 xh_vect = None 4601 if hasattr(data, 'xh_vect'): 4602 xh_vect = replace(`data.xh_vect.tolist()`, ' ', '') 4603 4604 # Relaxation data and errors. 4605 ri = [] 4606 ri_error = [] 4607 if hasattr(self.relax.data, 'num_ri'): 4608 for i in xrange(self.relax.data.num_ri[self.run]): 4609 try: 4610 # Find the residue specific data corresponding to i. 4611 index = None 4612 for j in xrange(data.num_ri): 4613 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]]: 4614 index = j 4615 4616 # Data exists for this data type. 4617 ri.append(`data.relax_data[index]`) 4618 ri_error.append(`data.relax_error[index]`) 4619 4620 # No data exists for this data type. 4621 except: 4622 ri.append(None) 4623 ri_error.append(None) 4624 4625 # Write the line. 4626 self.write_columnar_line(file=file, num=data.num, name=data.name, select=data.select, data_set='value', nucleus=nucleus, model=model, equation=equation, params=params, param_set=self.param_set, s2=`s2`, s2f=`s2f`, s2s=`s2s`, local_tm=`local_tm`, te=`te`, tf=`tf`, ts=`ts`, rex=`rex`, r=`r`, csa=`csa`, chi2=chi2, i=iter, f=f, g=g, h=h, warn=warn, diff_type=diff_type, diff_params=diff_params, pdb=pdb, pdb_model=pdb_model, pdb_heteronuc=pdb_heteronuc, pdb_proton=pdb_proton, xh_vect=xh_vect, ri_labels=ri_labels, remap_table=remap_table, frq_labels=frq_labels, frq=frq, ri=ri, ri_error=ri_error) 4627 4628 4629 # Errors. 4630 ######### 4631 4632 # Skip this section and the next if no simulations have been setup. 4633 if not hasattr(self.relax.data, 'sim_state'): 4634 return 4635 elif self.relax.data.sim_state[self.run] == 0: 4636 return 4637 4638 # Diffusion parameters. 4639 diff_params = None 4640 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run): 4641 # Isotropic. 4642 if self.relax.data.diff[self.run].type == 'iso': 4643 diff_params = [None] 4644 4645 # Axially symmetric. 4646 elif self.relax.data.diff[self.run].type == 'axial': 4647 diff_params = [None, None, None, None] 4648 4649 # Anisotropic. 4650 elif self.relax.data.diff[self.run].type == 'aniso': 4651 diff_params = [None, None, None, None, None, None] 4652 4653 # Diffusion parameter errors. 4654 if self.param_set == 'diff' or self.param_set == 'all': 4655 # Isotropic. 4656 if self.relax.data.diff[self.run].type == 'iso' and hasattr(self.relax.data.diff[self.run], 'tm_err'): 4657 diff_params = [`self.relax.data.diff[self.run].tm_err`] 4658 4659 # Axially symmetric. 4660 elif self.relax.data.diff[self.run].type == 'axial' and hasattr(self.relax.data.diff[self.run], 'tm_err'): 4661 diff_params = [`self.relax.data.diff[self.run].tm_err`, `self.relax.data.diff[self.run].Da_err`, `self.relax.data.diff[self.run].theta_err * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].phi_err * 360 / (2.0 * pi)`] 4662 4663 # Anisotropic. 4664 elif self.relax.data.diff[self.run].type == 'aniso' and hasattr(self.relax.data.diff[self.run], 'tm_err'): 4665 diff_params = [`self.relax.data.diff[self.run].tm_err`, `self.relax.data.diff[self.run].Da_err`, `self.relax.data.diff[self.run].Dr_err`, `self.relax.data.diff[self.run].alpha_err * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].beta_err * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].gamma_err * 360 / (2.0 * pi)`] 4666 4667 # Loop over the sequence. 4668 for i in xrange(len(self.relax.data.res[self.run])): 4669 # Reassign data structure. 4670 data = self.relax.data.res[self.run][i] 4671 4672 # Unselected residues. 4673 if not data.select: 4674 self.write_columnar_line(file=file, num=data.num, name=data.name, select=0, data_set='error') 4675 continue 4676 4677 # Model details. 4678 model = None 4679 if hasattr(data, 'model'): 4680 model = data.model 4681 4682 equation = None 4683 if hasattr(data, 'equation'): 4684 equation = data.equation 4685 4686 params = None 4687 if hasattr(data, 'params'): 4688 params = replace(`data.params`, ' ', '') 4689 4690 # S2. 4691 s2 = None 4692 if hasattr(data, 's2_err'): 4693 s2 = data.s2_err 4694 4695 # S2f. 4696 s2f = None 4697 if hasattr(data, 's2f_err'): 4698 s2f = data.s2f_err 4699 4700 # S2s. 4701 s2s = None 4702 if hasattr(data, 's2s_err'): 4703 s2s = data.s2s_err 4704 4705 # tm. 4706 local_tm = None 4707 if hasattr(data, 'tm_err') and data.tm_err != None: 4708 local_tm = data.tm_err / 1e-9 4709 4710 # te. 4711 te = None 4712 if hasattr(data, 'te_err') and data.te_err != None: 4713 te = data.te_err / 1e-12 4714 4715 # tf. 4716 tf = None 4717 if hasattr(data, 'tf_err') and data.tf_err != None: 4718 tf = data.tf_err / 1e-12 4719 4720 # ts. 4721 ts = None 4722 if hasattr(data, 'ts_err') and data.ts_err != None: 4723 ts = data.ts_err / 1e-12 4724 4725 # Rex. 4726 rex = None 4727 if hasattr(data, 'rex_err') and data.rex_err != None: 4728 rex = data.rex_err * (2.0 * pi * data.frq[0])**2 4729 4730 # Bond length. 4731 r = None 4732 if hasattr(data, 'r_err') and data.r_err != None: 4733 r = data.r_err / 1e-10 4734 4735 # CSA. 4736 csa = None 4737 if hasattr(data, 'csa_err') and data.csa_err != None: 4738 csa = data.csa_err / 1e-6 4739 4740 # Relaxation data and errors. 4741 ri = [] 4742 ri_error = [] 4743 for i in xrange(self.relax.data.num_ri[self.run]): 4744 ri.append(None) 4745 ri_error.append(None) 4746 4747 # XH vector. 4748 xh_vect = None 4749 if hasattr(data, 'xh_vect'): 4750 xh_vect = replace(`data.xh_vect.tolist()`, ' ', '') 4751 4752 # Write the line. 4753 self.write_columnar_line(file=file, num=data.num, name=data.name, select=data.select, data_set='error', nucleus=nucleus, model=model, equation=equation, params=params, param_set=self.param_set, s2=`s2`, s2f=`s2f`, s2s=`s2s`, local_tm=`local_tm`, te=`te`, tf=`tf`, ts=`ts`, rex=`rex`, r=`r`, csa=`csa`, diff_type=diff_type, diff_params=diff_params, pdb=pdb, pdb_model=pdb_model, pdb_heteronuc=pdb_heteronuc, pdb_proton=pdb_proton, xh_vect=xh_vect, ri_labels=ri_labels, remap_table=remap_table, frq_labels=frq_labels, frq=frq, ri=ri, ri_error=ri_error) 4754 4755 4756 # Simulation values. 4757 #################### 4758 4759 # Loop over the simulations. 4760 for i in xrange(self.relax.data.sim_number[self.run]): 4761 # Diffusion parameters. 4762 diff_params = None 4763 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run): 4764 # Diffusion parameter simulation values. 4765 if self.param_set == 'diff' or self.param_set == 'all': 4766 # Isotropic. 4767 if self.relax.data.diff[self.run].type == 'iso': 4768 diff_params = [`self.relax.data.diff[self.run].tm_sim[i]`] 4769 4770 # Axially symmetric. 4771 elif self.relax.data.diff[self.run].type == 'axial': 4772 diff_params = [`self.relax.data.diff[self.run].tm_sim[i]`, `self.relax.data.diff[self.run].Da_sim[i]`, `self.relax.data.diff[self.run].theta_sim[i] * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].phi_sim[i] * 360 / (2.0 * pi)`] 4773 4774 # Anisotropic. 4775 elif self.relax.data.diff[self.run].type == 'aniso': 4776 diff_params = [`self.relax.data.diff[self.run].tm_sim[i]`, `self.relax.data.diff[self.run].Da_sim[i]`, `self.relax.data.diff[self.run].Dr_sim[i]`, `self.relax.data.diff[self.run].alpha_sim[i] * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].beta_sim[i] * 360 / (2.0 * pi)`, `self.relax.data.diff[self.run].gamma_sim[i] * 360 / (2.0 * pi)`] 4777 4778 # No simulation values. 4779 else: 4780 # Isotropic. 4781 if self.relax.data.diff[self.run].type == 'iso': 4782 diff_params = [None] 4783 4784 # Axially symmetric. 4785 elif self.relax.data.diff[self.run].type == 'axial': 4786 diff_params = [None, None, None, None] 4787 4788 # Anisotropic. 4789 elif self.relax.data.diff[self.run].type == 'aniso': 4790 diff_params = [None, None, None, None, None, None] 4791 4792 # Loop over the sequence. 4793 for j in xrange(len(self.relax.data.res[self.run])): 4794 # Reassign data structure. 4795 data = self.relax.data.res[self.run][j] 4796 4797 # Unselected residues. 4798 if not data.select: 4799 self.write_columnar_line(file=file, num=data.num, name=data.name, select=0, data_set='sim_'+`i`) 4800 continue 4801 4802 # Model details. 4803 model = None 4804 if hasattr(data, 'model'): 4805 model = data.model 4806 4807 equation = None 4808 if hasattr(data, 'equation'): 4809 equation = data.equation 4810 4811 params = None 4812 if hasattr(data, 'params'): 4813 params = replace(`data.params`, ' ', '') 4814 4815 # S2. 4816 s2 = None 4817 if hasattr(data, 's2_sim'): 4818 s2 = data.s2_sim[i] 4819 4820 # S2f. 4821 s2f = None 4822 if hasattr(data, 's2f_sim'): 4823 s2f = data.s2f_sim[i] 4824 4825 # S2s. 4826 s2s = None 4827 if hasattr(data, 's2s_sim'): 4828 s2s = data.s2s_sim[i] 4829 4830 # tm. 4831 local_tm = None 4832 if hasattr(data, 'tm_sim') and data.tm_sim[i] != None: 4833 local_tm = data.tm_sim[i] / 1e-9 4834 4835 # te. 4836 te = None 4837 if hasattr(data, 'te_sim') and data.te_sim[i] != None: 4838 te = data.te_sim[i] / 1e-12 4839 4840 # tf. 4841 tf = None 4842 if hasattr(data, 'tf_sim') and data.tf_sim[i] != None: 4843 tf = data.tf_sim[i] / 1e-12 4844 4845 # ts. 4846 ts = None 4847 if hasattr(data, 'ts_sim') and data.ts_sim[i] != None: 4848 ts = data.ts_sim[i] / 1e-12 4849 4850 # Rex. 4851 rex = None 4852 if hasattr(data, 'rex_sim') and data.rex_sim[i] != None: 4853 rex = data.rex_sim[i] * (2.0 * pi * data.frq[0])**2 4854 4855 # Bond length. 4856 r = None 4857 if hasattr(data, 'r_sim') and data.r_sim[i] != None: 4858 r = data.r_sim[i] / 1e-10 4859 4860 # CSA. 4861 csa = None 4862 if hasattr(data, 'csa_sim') and data.csa_sim[i] != None: 4863 csa = data.csa_sim[i] / 1e-6 4864 4865 # Minimisation details. 4866 try: 4867 # Global minimisation results. 4868 if self.param_set == 'diff' or self.param_set == 'all': 4869 chi2 = self.relax.data.chi2_sim[self.run][i] 4870 iter = self.relax.data.iter_sim[self.run][i] 4871 f = self.relax.data.f_count_sim[self.run][i] 4872 g = self.relax.data.g_count_sim[self.run][i] 4873 h = self.relax.data.h_count_sim[self.run][i] 4874 if type(self.relax.data.warning_sim[self.run][i]) == str: 4875 warn = replace(self.relax.data.warning_sim[self.run][i], ' ', '_') 4876 else: 4877 warn = self.relax.data.warning_sim[self.run][i] 4878 4879 # Individual residue results. 4880 else: 4881 chi2 = data.chi2_sim[i] 4882 iter = data.iter_sim[i] 4883 f = data.f_count_sim[i] 4884 g = data.g_count_sim[i] 4885 h = data.h_count_sim[i] 4886 if type(data.warning_sim[i]) == str: 4887 warn = replace(data.warning_sim[i], ' ', '_') 4888 else: 4889 warn = data.warning_sim[i] 4890 4891 # No minimisation details. 4892 except AttributeError: 4893 chi2 = None 4894 iter = None 4895 f = None 4896 g = None 4897 h = None 4898 warn = None 4899 4900 # Relaxation data and errors. 4901 ri = [] 4902 ri_error = [] 4903 for k in xrange(self.relax.data.num_ri[self.run]): 4904 # Find the residue specific data corresponding to k. 4905 index = None 4906 for l in xrange(data.num_ri): 4907 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]]: 4908 index = l 4909 4910 # Data exists for this data type. 4911 try: 4912 ri.append(`data.relax_sim_data[i][index]`) 4913 ri_error.append(`data.relax_error[index]`) 4914 except: 4915 ri.append(None) 4916 ri_error.append(None) 4917 4918 # XH vector. 4919 xh_vect = None 4920 if hasattr(data, 'xh_vect'): 4921 xh_vect = replace(`data.xh_vect.tolist()`, ' ', '') 4922 4923 # Write the line. 4924 self.write_columnar_line(file=file, num=data.num, name=data.name, select=data.select, data_set='sim_'+`i`, nucleus=nucleus, model=model, equation=equation, params=params, param_set=self.param_set, s2=`s2`, s2f=`s2f`, s2s=`s2s`, local_tm=`local_tm`, te=`te`, tf=`tf`, ts=`ts`, rex=`rex`, r=`r`, csa=`csa`, chi2=`chi2`, i=iter, f=f, g=g, h=h, warn=warn, diff_type=diff_type, diff_params=diff_params, pdb=pdb, pdb_model=pdb_model, pdb_heteronuc=pdb_heteronuc, pdb_proton=pdb_proton, xh_vect=xh_vect, ri_labels=ri_labels, remap_table=remap_table, frq_labels=frq_labels, frq=frq, ri=ri, ri_error=ri_error)

Source Code for Module specific_fns.model_free