specific_fns.model

38 - def __init__(self, relax):

39 """Class containing functions specific to model-free analysis.""" 40 41 self.relax = relax 42 43 # Class containing the Molmol specific functions. 44 self.molmol = Molmol(self.relax)

45 46

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

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

98 99

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

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

142 143

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

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

305 306

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

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

390 391

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

393 """Back-calculation of relaxation data from the model-free parameter values.""" 394 395 # Run argument. 396 self.run = run 397 398 # Get the relaxation value from the minimise function. 399 value = self.minimise(run=self.run, min_algor='back_calc', min_options=(index, ri_label, frq_label, frq)) 400 401 # Return the relaxation value. 402 return value

403 404

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

406 """Calculation of the model-free chi-squared value.""" 407 408 # Arguments. 409 self.run = run 410 self.print_flag = print_flag 411 412 # Test if the sequence data for self.run is loaded. 413 if not self.relax.data.res.has_key(self.run): 414 raise RelaxNoSequenceError, self.run 415 416 # The residue index. 417 index = None 418 if res_num != None: 419 # Loop over the sequence. 420 for i in xrange(len(self.relax.data.res[self.run])): 421 # Found the residue. 422 if self.relax.data.res[self.run][i].num == res_num: 423 index = i 424 break 425 426 # Can't find the residue. 427 if index == None: 428 raise RelaxNoResError, res_num 429 430 # Determine the parameter set type. 431 self.param_set = self.determine_param_set_type() 432 433 # Test if diffusion tensor data for the run exists. 434 if self.param_set != 'local_tm' and not self.relax.data.diff.has_key(self.run): 435 raise RelaxNoTensorError, self.run 436 437 # Test if the PDB file has been loaded. 438 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'sphere' and not self.relax.data.pdb.has_key(self.run): 439 raise RelaxNoPdbError, self.run 440 441 # Test if the nucleus type has been set. 442 if not hasattr(self.relax.data, 'gx'): 443 raise RelaxNucleusError 444 445 # Loop over the residues. 446 for i in xrange(len(self.relax.data.res[self.run])): 447 # Alias the data structure. 448 data = self.relax.data.res[self.run][i] 449 450 # Skip unselected residues. 451 if not data.select: 452 continue 453 454 # Single residue. 455 if index != None and index != i: 456 continue 457 458 # Test if the model-free model has been setup. 459 if not data.model: 460 raise RelaxNoModelError, self.run 461 462 # Test if unit vectors exist. 463 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'sphere' and not hasattr(data, 'xh_vect'): 464 raise RelaxNoVectorsError, self.run 465 466 # Test if the model-free parameter values exist. 467 unset_param = self.are_mf_params_set(i) 468 if unset_param != None: 469 raise RelaxNoValueError, unset_param 470 471 # Test if the CSA value has been set. 472 if not hasattr(data, 'csa') or data.csa == None: 473 raise RelaxNoValueError, "CSA" 474 475 # Test if the bond length value has been set. 476 if not hasattr(data, 'r') or data.r == None: 477 raise RelaxNoValueError, "bond length" 478 479 # Skip residues where there is no data or errors. 480 if not hasattr(data, 'relax_data') or not hasattr(data, 'relax_error'): 481 continue 482 483 # Make sure that the errors are strictly positive numbers. 484 for j in xrange(len(data.relax_error)): 485 if data.relax_error[j] == 0.0: 486 raise RelaxError, "Zero error for residue '" + `data.num` + " " + data.name + "', calculation not possible." 487 elif data.relax_error[j] < 0.0: 488 raise RelaxError, "Negative error for residue '" + `data.num` + " " + data.name + "', calculation not possible." 489 490 # Create the initial parameter vector. 491 self.param_vector = self.assemble_param_vector(index=i, sim_index=sim_index) 492 493 # Repackage the data. 494 if sim_index == None: 495 relax_data = [data.relax_data] 496 r = [data.r] 497 csa = [data.csa] 498 else: 499 relax_data = [data.relax_sim_data[sim_index]] 500 r = [data.r_sim[sim_index]] 501 csa = [data.csa_sim[sim_index]] 502 503 # Vectors. 504 if self.param_set != 'local_tm' and self.relax.data.diff[self.run].type != 'sphere': 505 xh_unit_vectors = [data.xh_vect] 506 else: 507 xh_unit_vectors = [None] 508 509 # Count the number of model-free parameters for the residue index. 510 num_params = [len(data.params)] 511 512 # Repackage the parameter values for minimising just the diffusion tensor parameters. 513 param_values = [self.assemble_param_vector(param_set='mf')] 514 515 # Convert to Numeric arrays. 516 relax_data = [array(data.relax_data, Float64)] 517 relax_error = [array(data.relax_error, Float64)] 518 519 # Package the diffusion tensor parameters. 520 if self.param_set == 'local_tm': 521 diff_params = [self.relax.data.res[self.run][i].local_tm] 522 diff_type = 'sphere' 523 else: 524 # Alias. 525 diff_data = self.relax.data.diff[self.run] 526 527 # Diff type. 528 diff_type = diff_data.type 529 530 # Spherical diffusion. 531 if diff_type == 'sphere': 532 diff_params = [diff_data.tm] 533 534 # Spheroidal diffusion. 535 elif diff_type == 'spheroid': 536 diff_params = [diff_data.tm, diff_data.Da, diff_data.theta, diff_data.phi] 537 538 # Ellipsoidal diffusion. 539 elif diff_type == 'ellipsoid': 540 diff_params = [diff_data.tm, diff_data.Da, diff_data.Dr, diff_data.alpha, diff_data.beta, diff_data.gamma] 541 542 # Initialise the model-free function. 543 self.mf = Mf(init_params=self.param_vector, param_set='mf', diff_type=diff_type, diff_params=diff_params, num_res=1, equations=[data.equation], param_types=[data.params], param_values=param_values, relax_data=relax_data, errors=relax_error, bond_length=r, csa=csa, num_frq=[data.num_frq], frq=[data.frq], num_ri=[data.num_ri], remap_table=[data.remap_table], noe_r1_table=[data.noe_r1_table], ri_labels=[data.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) 544 545 # Chi-squared calculation. 546 try: 547 chi2 = self.mf.func(self.param_vector) 548 except OverflowError: 549 chi2 = 1e200 550 551 # Global chi-squared value. 552 if self.param_set == 'all' or self.param_set == 'diff': 553 self.relax.data.chi2[self.run] = self.relax.data.chi2[self.run] + chi2 554 else: 555 self.relax.data.res[self.run][i].chi2 = chi2

556 557

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

559 """Function for copying all model-free data from run1 to run2.""" 560 561 # Test if run1 exists. 562 if not run1 in self.relax.data.run_names: 563 raise RelaxNoRunError, run1 564 565 # Test if run2 exists. 566 if not run2 in self.relax.data.run_names: 567 raise RelaxNoRunError, run2 568 569 # Test if the run type of run1 is set to 'mf'. 570 function_type = self.relax.data.run_types[self.relax.data.run_names.index(run1)] 571 if function_type != 'mf': 572 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 573 574 # Test if the run type of run2 is set to 'mf'. 575 function_type = self.relax.data.run_types[self.relax.data.run_names.index(run2)] 576 if function_type != 'mf': 577 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 578 579 # Test if the sequence data for run1 is loaded. 580 if not self.relax.data.res.has_key(run1): 581 raise RelaxNoSequenceError, run1 582 583 # Test if the sequence data for run2 is loaded. 584 if not self.relax.data.res.has_key(run2): 585 raise RelaxNoSequenceError, run2 586 587 # Get all data structure names. 588 names = self.data_names() 589 590 # Copy the data. 591 for i in xrange(len(self.relax.data.res[run1])): 592 # Remap the data structure 'self.relax.data.res[run1][i]'. 593 data1 = self.relax.data.res[run1][i] 594 data2 = self.relax.data.res[run2][i] 595 596 # Loop through the data structure names. 597 for name in names: 598 # All data. 599 if not sim: 600 # Skip the data structure if it does not exist. 601 if not hasattr(data1, name): 602 continue 603 604 # Copy the data structure. 605 setattr(data2, name, deepcopy(getattr(data1, name))) 606 607 # Copy just the simulation data for the simulation 'sim'. 608 else: 609 # Sim data name 610 name = name + '_sim' 611 612 # Skip the data structure if it does not exist in both runs. 613 if not hasattr(data1, name) or not hasattr(data2, name): 614 continue 615 616 # Get the objects. 617 object1 = getattr(data1, name) 618 object2 = getattr(data2, name) 619 620 # Copy the data. 621 object2[sim] = object1[sim]

622 623

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

625 """Function for creating the Monte Carlo Ri data.""" 626 627 # Arguments 628 self.run = run 629 630 # Initialise the data data structure. 631 data = [] 632 633 # Test if the model is set. 634 if not hasattr(self.relax.data.res[self.run][i], 'model') or not self.relax.data.res[self.run][i].model: 635 raise RelaxNoModelError, self.run 636 637 # Loop over the relaxation data. 638 for j in xrange(len(self.relax.data.res[run][i].relax_data)): 639 # Back calculate the value. 640 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]]) 641 642 # Append the value. 643 data.append(value) 644 645 # Return the data. 646 return data

647 648

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

650 """Function to create a model-free model.""" 651 652 # Run argument. 653 self.run = run 654 655 # Test if the run exists. 656 if not self.run in self.relax.data.run_names: 657 raise RelaxNoRunError, self.run 658 659 # Test if the run type is set to 'mf'. 660 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 661 if function_type != 'mf': 662 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 663 664 # Test if sequence data is loaded. 665 if not self.relax.data.res.has_key(self.run): 666 raise RelaxNoSequenceError, self.run 667 668 # Check the validity of the model-free equation type. 669 valid_types = ['mf_orig', 'mf_ext', 'mf_ext2'] 670 if not equation in valid_types: 671 raise RelaxError, "The model-free equation type argument " + `equation` + " is invalid and should be one of " + `valid_types` + "." 672 673 # Check the validity of the parameter array. 674 s2, te, s2f, tf, s2s, ts, rex, csa, r = 0, 0, 0, 0, 0, 0, 0, 0, 0 675 for i in xrange(len(params)): 676 # Invalid parameter flag. 677 invalid_param = 0 678 679 # S2. 680 if params[i] == 'S2': 681 # Does the array contain more than one instance of S2. 682 if s2: 683 invalid_param = 1 684 s2 = 1 685 686 # Does the array contain S2s. 687 s2s_flag = 0 688 for j in xrange(len(params)): 689 if params[j] == 'S2s': 690 s2s_flag = 1 691 if s2s_flag: 692 invalid_param = 1 693 694 # te. 695 elif params[i] == 'te': 696 # Does the array contain more than one instance of te and has the extended model-free formula been selected. 697 if equation == 'mf_ext' or te: 698 invalid_param = 1 699 te = 1 700 701 # Does the array contain the parameter S2. 702 s2_flag = 0 703 for j in xrange(len(params)): 704 if params[j] == 'S2': 705 s2_flag = 1 706 if not s2_flag: 707 invalid_param = 1 708 709 # S2f. 710 elif params[i] == 'S2f': 711 # Does the array contain more than one instance of S2f and has the original model-free formula been selected. 712 if equation == 'mf_orig' or s2f: 713 invalid_param = 1 714 s2f = 1 715 716 # S2s. 717 elif params[i] == 'S2s': 718 # Does the array contain more than one instance of S2s and has the original model-free formula been selected. 719 if equation == 'mf_orig' or s2s: 720 invalid_param = 1 721 s2s = 1 722 723 # tf. 724 elif params[i] == 'tf': 725 # Does the array contain more than one instance of tf and has the original model-free formula been selected. 726 if equation == 'mf_orig' or tf: 727 invalid_param = 1 728 tf = 1 729 730 # Does the array contain the parameter S2f. 731 s2f_flag = 0 732 for j in xrange(len(params)): 733 if params[j] == 'S2f': 734 s2f_flag = 1 735 if not s2f_flag: 736 invalid_param = 1 737 738 # ts. 739 elif params[i] == 'ts': 740 # Does the array contain more than one instance of ts and has the original model-free formula been selected. 741 if equation == 'mf_orig' or ts: 742 invalid_param = 1 743 ts = 1 744 745 # Does the array contain the parameter S2 or S2s. 746 flag = 0 747 for j in xrange(len(params)): 748 if params[j] == 'S2' or params[j] == 'S2f': 749 flag = 1 750 if not flag: 751 invalid_param = 1 752 753 # Rex. 754 elif params[i] == 'Rex': 755 if rex: 756 invalid_param = 1 757 rex = 1 758 759 # Bond length. 760 elif params[i] == 'r': 761 if r: 762 invalid_param = 1 763 r = 1 764 765 # CSA. 766 elif params[i] == 'CSA': 767 if csa: 768 invalid_param = 1 769 csa = 1 770 771 # Unknown parameter. 772 else: 773 raise RelaxError, "The parameter " + params[i] + " is not supported." 774 775 # The invalid parameter flag is set. 776 if invalid_param: 777 raise RelaxError, "The parameter array " + `params` + " contains an invalid combination of parameters." 778 779 # Set up the model. 780 self.model_setup(run, model, equation, params, res_num)

781 782

783 - def data_init(self, data):

784 """Function for initialising the data structures.""" 785 786 # Get the data names. 787 data_names = self.data_names() 788 789 # Loop over the data structure names. 790 for name in data_names: 791 # Data structures which are initially empty arrays. 792 list_data = [ 'params' ] 793 if name in list_data: 794 init_data = [] 795 796 # Data structures which are initially None. 797 none_data = [ 'equation', 798 'model', 799 's2', 800 's2f', 801 's2s', 802 'local_tm', 803 'te', 804 'tf', 805 'ts', 806 'rex', 807 'r', 808 'csa', 809 'chi2', 810 'iter', 811 'f_count', 812 'g_count', 813 'h_count', 814 'warning' ] 815 if name in none_data: 816 init_data = None 817 818 # If the name is not in 'data', add it. 819 if not hasattr(data, name): 820 setattr(data, name, init_data)

821 822

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

824 """Function for returning a list of names of data structures. 825 826 Description 827 ~~~~~~~~~~~ 828 829 The names are as follows: 830 831 model: The model-free model name. 832 833 equation: The model-free equation type. 834 835 params: An array of the model-free parameter names associated with the model. 836 837 s2: S2. 838 839 s2f: S2f. 840 841 s2s: S2s. 842 843 local_tm: local tm. 844 845 te: te. 846 847 tf: tf. 848 849 ts: ts. 850 851 rex: Rex. 852 853 r: Bond length. 854 855 csa: CSA value. 856 857 chi2: Chi-squared value. 858 859 iter: Iterations. 860 861 f_count: Function count. 862 863 g_count: Gradient count. 864 865 h_count: Hessian count. 866 867 warning: Minimisation warning. 868 """ 869 870 # Initialise. 871 names = [] 872 873 # Generic. 874 if set == 'all' or set == 'generic': 875 names.append('model') 876 names.append('equation') 877 names.append('params') 878 879 # Parameters. 880 if set == 'all' or set == 'params': 881 names.append('s2') 882 names.append('s2f') 883 names.append('s2s') 884 names.append('local_tm') 885 names.append('te') 886 names.append('tf') 887 names.append('ts') 888 names.append('rex') 889 names.append('r') 890 names.append('csa') 891 892 # Minimisation statistics. 893 if set == 'all' or set == 'min': 894 names.append('chi2') 895 names.append('iter') 896 names.append('f_count') 897 names.append('g_count') 898 names.append('h_count') 899 names.append('warning') 900 901 return names

902 903

904 - def default_value(self, param):

905 """ 906 Model-free default values 907 ~~~~~~~~~~~~~~~~~~~~~~~~~ 908 909 _______________________________________________________________________________________ 910 | | | | 911 | Data type | Object name | Value | 912 |_______________________________________|____________________|________________________| 913 | | | | 914 | Local tm | 'local_tm' | 10 * 1e-9 | 915 | | | | 916 | Order parameters S2, S2f, and S2s | 's2', 's2f', 's2s' | 0.8 | 917 | | | | 918 | Correlation time te | 'te' | 100 * 1e-12 | 919 | | | | 920 | Correlation time tf | 'tf' | 10 * 1e-12 | 921 | | | | 922 | Correlation time ts | 'ts' | 1000 * 1e-12 | 923 | | | | 924 | Chemical exchange relaxation | 'rex' | 0.0 | 925 | | | | 926 | Bond length | 'r' | 1.02 * 1e-10 | 927 | | | | 928 | CSA | 'csa' | -172 * 1e-6 | 929 |_______________________________________|____________________|________________________| 930 931 """ 932 933 # Local tm. 934 if param == 'local_tm': 935 return 10.0 * 1e-9 936 937 # {S2, S2f, S2s}. 938 elif search('^S2', param): 939 return 0.8 940 941 # te. 942 elif param == 'te': 943 return 100.0 * 1e-12 944 945 # tf. 946 elif param == 'tf': 947 return 10.0 * 1e-12 948 949 # ts. 950 elif param == 'ts': 951 return 1000.0 * 1e-12 952 953 # Rex. 954 elif param == 'Rex': 955 return 0.0 956 957 # Bond length. 958 elif param == 'r': 959 return 1.02 * 1e-10 960 961 # CSA. 962 elif param == 'CSA': 963 return -172 * 1e-6

964 965

966 - def delete(self, run):

967 """Function for deleting all model-free data.""" 968 969 # Arguments. 970 self.run = run 971 972 # Test if the run exists. 973 if not self.run in self.relax.data.run_names: 974 raise RelaxNoRunError, self.run 975 976 # Test if the run type is set to 'mf'. 977 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 978 if function_type != 'mf': 979 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 980 981 # Test if the sequence data is loaded. 982 if not self.relax.data.res.has_key(self.run): 983 raise RelaxNoSequenceError, self.run 984 985 # Get all data structure names. 986 names = self.data_names() 987 988 # Loop over the sequence. 989 for i in xrange(len(self.relax.data.res[self.run])): 990 # Remap the data structure 'self.relax.data.res[self.run][i]'. 991 data = self.relax.data.res[self.run][i] 992 993 # Loop through the data structure names. 994 for name in names: 995 # Skip the data structure if it does not exist. 996 if not hasattr(data, name): 997 continue 998 999 # Delete the data. 1000 delattr(data, name) 1001 1002 # Clean up the runs. 1003 self.relax.generic.runs.eliminate_unused_runs()

1004 1005

1006 - def determine_param_set_type(self, run=None):

1007 """Determine the type of parameter set.""" 1008 1009 # Run name. 1010 if run: 1011 self.run = run 1012 1013 # Test if sequence data is loaded. 1014 if not self.relax.data.res.has_key(self.run): 1015 raise RelaxNoSequenceError, self.run 1016 1017 # If there is a local tm, fail if not all residues have a local tm parameter. 1018 local_tm = 0 1019 for i in xrange(len(self.relax.data.res[self.run])): 1020 # Skip unselected residues. 1021 # This code causes a bug after model elimination if the model has been eliminated (select = 0). 1022 #if not self.relax.data.res[self.run][i].select: 1023 # continue 1024 1025 # No params. 1026 if not hasattr(self.relax.data.res[self.run][i], 'params') or not self.relax.data.res[self.run][i].params: 1027 continue 1028 1029 # Local tm. 1030 if local_tm == 0 and 'local_tm' in self.relax.data.res[self.run][i].params: 1031 local_tm = 1 1032 1033 # Inconsistencies. 1034 elif local_tm == 1 and not 'local_tm' in self.relax.data.res[self.run][i].params: 1035 raise RelaxError, "All residues must either have a local tm parameter or not." 1036 1037 # Check if any model-free parameters are allowed to vary. 1038 mf_all_fixed = 1 1039 for i in xrange(len(self.relax.data.res[self.run])): 1040 # Skip unselected residues. 1041 # This code causes a bug after model elimination if the model has been eliminated (select = 0). 1042 #if not self.relax.data.res[self.run][i].select: 1043 # continue 1044 1045 # Test the fixed flag. 1046 if not hasattr(self.relax.data.res[self.run][i], 'fixed'): 1047 mf_all_fixed = 0 1048 break 1049 if not self.relax.data.res[self.run][i].fixed: 1050 mf_all_fixed = 0 1051 break 1052 1053 # Local tm. 1054 if local_tm: 1055 return 'local_tm' 1056 1057 # Test if the diffusion tensor data is loaded. 1058 if not self.relax.data.diff.has_key(self.run): 1059 raise RelaxNoTensorError, self.run 1060 1061 # 'diff' parameter set. 1062 if mf_all_fixed: 1063 # All parameters fixed. 1064 if self.relax.data.diff[self.run].fixed: 1065 raise RelaxError, "All parameters are fixed." 1066 1067 return 'diff' 1068 1069 # 'mf' parameter set. 1070 if self.relax.data.diff[self.run].fixed: 1071 return 'mf' 1072 1073 # 'all' parameter set. 1074 else: 1075 return 'all'

1076 1077

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

1079 """Function for disassembling the parameter vector.""" 1080 1081 # Initialise. 1082 param_index = 0 1083 1084 # Diffusion tensor parameters of the Monte Carlo simulations. 1085 if sim_index != None and (self.param_set == 'diff' or self.param_set == 'all'): 1086 # Spherical diffusion. 1087 if self.relax.data.diff[self.run].type == 'sphere': 1088 # Sim values. 1089 self.relax.data.diff[self.run].tm_sim[sim_index] = self.param_vector[0] 1090 1091 # Parameter index. 1092 param_index = param_index + 1 1093 1094 # Spheroidal diffusion. 1095 elif self.relax.data.diff[self.run].type == 'spheroid': 1096 # Sim values. 1097 self.relax.data.diff[self.run].tm_sim[sim_index] = self.param_vector[0] 1098 self.relax.data.diff[self.run].Da_sim[sim_index] = self.param_vector[1] 1099 self.relax.data.diff[self.run].theta_sim[sim_index] = self.param_vector[2] 1100 self.relax.data.diff[self.run].phi_sim[sim_index] = self.param_vector[3] 1101 self.relax.generic.diffusion_tensor.fold_angles(run=self.run, sim_index=sim_index) 1102 1103 # Parameter index. 1104 param_index = param_index + 4 1105 1106 # Ellipsoidal diffusion. 1107 elif self.relax.data.diff[self.run].type == 'ellipsoid': 1108 # Sim values. 1109 self.relax.data.diff[self.run].tm_sim[sim_index] = self.param_vector[0] 1110 self.relax.data.diff[self.run].Da_sim[sim_index] = self.param_vector[1] 1111 self.relax.data.diff[self.run].Dr_sim[sim_index] = self.param_vector[2] 1112 self.relax.data.diff[self.run].alpha_sim[sim_index] = self.param_vector[3] 1113 self.relax.data.diff[self.run].beta_sim[sim_index] = self.param_vector[4] 1114 self.relax.data.diff[self.run].gamma_sim[sim_index] = self.param_vector[5] 1115 self.relax.generic.diffusion_tensor.fold_angles(run=self.run, sim_index=sim_index) 1116 1117 # Parameter index. 1118 param_index = param_index + 6 1119 1120 # Diffusion tensor parameters. 1121 elif self.param_set == 'diff' or self.param_set == 'all': 1122 # Spherical diffusion. 1123 if self.relax.data.diff[self.run].type == 'sphere': 1124 # Values. 1125 self.relax.data.diff[self.run].tm = self.param_vector[0] 1126 1127 # Parameter index. 1128 param_index = param_index + 1 1129 1130 # Spheroidal diffusion. 1131 elif self.relax.data.diff[self.run].type == 'spheroid': 1132 # Values. 1133 self.relax.data.diff[self.run].tm = self.param_vector[0] 1134 self.relax.data.diff[self.run].Da = self.param_vector[1] 1135 self.relax.data.diff[self.run].theta = self.param_vector[2] 1136 self.relax.data.diff[self.run].phi = self.param_vector[3] 1137 self.relax.generic.diffusion_tensor.fold_angles(run=self.run) 1138 1139 # Parameter index. 1140 param_index = param_index + 4 1141 1142 # Ellipsoidal diffusion. 1143 elif self.relax.data.diff[self.run].type == 'ellipsoid': 1144 # Values. 1145 self.relax.data.diff[self.run].tm = self.param_vector[0] 1146 self.relax.data.diff[self.run].Da = self.param_vector[1] 1147 self.relax.data.diff[self.run].Dr = self.param_vector[2] 1148 self.relax.data.diff[self.run].alpha = self.param_vector[3] 1149 self.relax.data.diff[self.run].beta = self.param_vector[4] 1150 self.relax.data.diff[self.run].gamma = self.param_vector[5] 1151 self.relax.generic.diffusion_tensor.fold_angles(run=self.run) 1152 1153 # Parameter index. 1154 param_index = param_index + 6 1155 1156 # Model-free parameters. 1157 if self.param_set != 'diff': 1158 # Loop over all residues. 1159 for i in xrange(len(self.relax.data.res[self.run])): 1160 # Remap the residue data structure. 1161 data = self.relax.data.res[self.run][i] 1162 1163 # Skip unselected residues. 1164 if not data.select: 1165 continue 1166 1167 # Only add parameters for a single residue if index has a value. 1168 if index != None and i != index: 1169 continue 1170 1171 # Loop over the model-free parameters. 1172 for j in xrange(len(data.params)): 1173 # Local tm. 1174 if data.params[j] == 'local_tm': 1175 if sim_index == None: 1176 data.local_tm = self.param_vector[param_index] 1177 else: 1178 data.local_tm_sim[sim_index] = self.param_vector[param_index] 1179 1180 # S2. 1181 elif data.params[j] == 'S2': 1182 if sim_index == None: 1183 data.s2 = self.param_vector[param_index] 1184 else: 1185 data.s2_sim[sim_index] = self.param_vector[param_index] 1186 1187 # S2f. 1188 elif data.params[j] == 'S2f': 1189 if sim_index == None: 1190 data.s2f = self.param_vector[param_index] 1191 else: 1192 data.s2f_sim[sim_index] = self.param_vector[param_index] 1193 1194 # S2s. 1195 elif data.params[j] == 'S2s': 1196 if sim_index == None: 1197 data.s2s = self.param_vector[param_index] 1198 else: 1199 data.s2s_sim[sim_index] = self.param_vector[param_index] 1200 1201 # te. 1202 elif data.params[j] == 'te': 1203 if sim_index == None: 1204 data.te = self.param_vector[param_index] 1205 else: 1206 data.te_sim[sim_index] = self.param_vector[param_index] 1207 1208 # tf. 1209 elif data.params[j] == 'tf': 1210 if sim_index == None: 1211 data.tf = self.param_vector[param_index] 1212 else: 1213 data.tf_sim[sim_index] = self.param_vector[param_index] 1214 1215 # ts. 1216 elif data.params[j] == 'ts': 1217 if sim_index == None: 1218 data.ts = self.param_vector[param_index] 1219 else: 1220 data.ts_sim[sim_index] = self.param_vector[param_index] 1221 1222 # Rex. 1223 elif data.params[j] == 'Rex': 1224 if sim_index == None: 1225 data.rex = self.param_vector[param_index] 1226 else: 1227 data.rex_sim[sim_index] = self.param_vector[param_index] 1228 1229 # r. 1230 elif data.params[j] == 'r': 1231 if sim_index == None: 1232 data.r = self.param_vector[param_index] 1233 else: 1234 data.r_sim[sim_index] = self.param_vector[param_index] 1235 1236 # CSA. 1237 elif data.params[j] == 'CSA': 1238 if sim_index == None: 1239 data.csa = self.param_vector[param_index] 1240 else: 1241 data.csa_sim[sim_index] = self.param_vector[param_index] 1242 1243 # Unknown parameter. 1244 else: 1245 raise RelaxError, "Unknown parameter." 1246 1247 # Increment the parameter index. 1248 param_index = param_index + 1 1249 1250 # Calculate all order parameters after unpacking the vector. 1251 if self.param_set != 'diff': 1252 # Loop over all residues. 1253 for i in xrange(len(self.relax.data.res[self.run])): 1254 # Remap the residue data structure. 1255 data = self.relax.data.res[self.run][i] 1256 1257 # Skip unselected residues. 1258 if not data.select: 1259 continue 1260 1261 # Only add parameters for a single residue if index has a value. 1262 if index != None and i != index: 1263 continue 1264 1265 # Normal values. 1266 if sim_index == None: 1267 # S2. 1268 if 'S2' not in data.params and 'S2f' in data.params and 'S2s' in data.params: 1269 data.s2 = data.s2f * data.s2s 1270 1271 # S2f. 1272 if 'S2f' not in data.params and 'S2' in data.params and 'S2s' in data.params: 1273 if data.s2s == 0.0: 1274 data.s2f = 1e99 1275 else: 1276 data.s2f = data.s2 / data.s2s 1277 1278 # S2s. 1279 if 'S2s' not in data.params and 'S2' in data.params and 'S2f' in data.params: 1280 if data.s2f == 0.0: 1281 data.s2s = 1e99 1282 else: 1283 data.s2s = data.s2 / data.s2f 1284 1285 # Simulation values. 1286 else: 1287 # S2. 1288 if 'S2' not in data.params and 'S2f' in data.params and 'S2s' in data.params: 1289 data.s2_sim[sim_index] = data.s2f_sim[sim_index] * data.s2s_sim[sim_index] 1290 1291 # S2f. 1292 if 'S2f' not in data.params and 'S2' in data.params and 'S2s' in data.params: 1293 if data.s2s_sim[sim_index] == 0.0: 1294 data.s2f_sim[sim_index] = 1e99 1295 else: 1296 data.s2f_sim[sim_index] = data.s2_sim[sim_index] / data.s2s_sim[sim_index] 1297 1298 # S2s. 1299 if 'S2s' not in data.params and 'S2' in data.params and 'S2f' in data.params: 1300 if data.s2f_sim[sim_index] == 0.0: 1301 data.s2s_sim[sim_index] = 1e99 1302 else: 1303 data.s2s_sim[sim_index] = data.s2_sim[sim_index] / data.s2f_sim[sim_index]

1304 1305

1306 - def duplicate_data(self, new_run=None, old_run=None, instance=None, global_stats=0):

1307 """Function for duplicating data.""" 1308 1309 # self.run for determining the parameter set. 1310 self.run = old_run 1311 1312 # Duplicate all non-residue specific data. 1313 for data_name in dir(self.relax.data): 1314 # Skip 'res'. 1315 if data_name == 'res': 1316 continue 1317 1318 # Get the object. 1319 data = getattr(self.relax.data, data_name) 1320 1321 # Skip the data if it is not a dictionary (or equivalent). 1322 if not hasattr(data, 'has_key'): 1323 continue 1324 1325 # Skip the data if it doesn't contain the key 'old_run'. 1326 if not data.has_key(old_run): 1327 continue 1328 1329 # If the dictionary already contains the key 'new_run', but the data is different, raise an error (skip PDB and diffusion data). 1330 if data_name != 'pdb' and data_name != 'diff' and data.has_key(new_run) and data[old_run] != data[new_run]: 1331 raise RelaxError, "The data between run " + `new_run` + " and run " + `old_run` + " is not consistent." 1332 1333 # Skip the data if it contains the key 'new_run'. 1334 if data.has_key(new_run): 1335 continue 1336 1337 # Duplicate the data. 1338 data[new_run] = deepcopy(data[old_run]) 1339 1340 # Determine the parameter set type. 1341 self.param_set = self.determine_param_set_type() 1342 1343 # Sequence specific data. 1344 if self.param_set == 'mf' or (self.param_set == 'local_tm' and not global_stats): 1345 # Create the sequence data if it does not exist. 1346 if not self.relax.data.res.has_key(new_run) or not len(self.relax.data.res[new_run]): 1347 # Add the new run to 'self.relax.data.res'. 1348 self.relax.data.res.add_list(new_run) 1349 1350 # Fill the array 'self.relax.data.res[new_run]' with empty data containers and place sequence data into the array. 1351 for i in xrange(len(self.relax.data.res[old_run])): 1352 # Append a data container. 1353 self.relax.data.res[new_run].add_item() 1354 1355 # Insert the data. 1356 self.relax.data.res[new_run][i].num = self.relax.data.res[old_run][i].num 1357 self.relax.data.res[new_run][i].name = self.relax.data.res[old_run][i].name 1358 self.relax.data.res[new_run][i].select = self.relax.data.res[old_run][i].select 1359 1360 # Duplicate the residue specific data. 1361 self.relax.data.res[new_run][instance] = deepcopy(self.relax.data.res[old_run][instance]) 1362 1363 # Other data types. 1364 else: 1365 # Duplicate the residue specific data. 1366 self.relax.data.res[new_run] = deepcopy(self.relax.data.res[old_run])

1367 1368

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

1370 """ 1371 Local tm model elimination rule 1372 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1373 1374 The local tm, in some cases, may exceed the value expected for a global correlation time. 1375 Generally the tm value will be stuck at the upper limit defined for the parameter. These 1376 models are eliminated using the rule: 1377 1378 tm >= c 1379 1380 The default value of c is 50 ns, although this can be overridden by supplying the value (in 1381 seconds) as the first element of the args tuple. 1382 1383 1384 Internal correlation times {te, tf, ts} model elimination rules 1385 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1386 1387 These parameters may experience the same problem as the local tm in that the model fails and 1388 the parameter value is stuck at the upper limit. These parameters are constrained using the 1389 formula (te, tf, ts <= 2tm). These failed models are eliminated using the rule: 1390 1391 te, tf, ts >= c . tm 1392 1393 The default value of c is 1.5. Because of round-off errors and the constraint algorithm, 1394 setting c to 2 will result in no models being eliminated as the minimised parameters will 1395 always be less than 2tm. The value can be changed by supplying the value as the second 1396 element of the tuple. 1397 1398 1399 Arguments 1400 ~~~~~~~~~ 1401 1402 The 'args' argument must be a tuple of length 2, the elements of which must be numbers. For 1403 example, to eliminate models which have a local tm value greater than 25 ns and models with 1404 internal correlation times greater than 1.5 times tm, set 'args' to (25 * 1e-9, 1.5). 1405 """ 1406 1407 # Default values. 1408 c1 = 50.0 * 1e-9 1409 c2 = 1.5 1410 1411 # Depack the arguments. 1412 if args != None: 1413 c1, c2 = args 1414 1415 # Get the tm value. 1416 if self.param_set == 'local_tm': 1417 tm = self.relax.data.res[run][i].local_tm 1418 else: 1419 tm = self.relax.data.diff[run].tm 1420 1421 # Local tm. 1422 if name == 'local_tm' and value >= c1: 1423 print "The local tm parameter of " + `value` + " is greater than " + `c1` + ", eliminating spin system " + `self.relax.data.res[run][i].num` + " " + self.relax.data.res[run][i].name + " of the run " + `run` 1424 return 1 1425 1426 # Internal correlation times. 1427 if match('t[efs]', name) and value >= c2 * tm: 1428 print "The " + name + " value of " + `value` + " is greater than " + `c2 * tm` + ", eliminating spin system " + `self.relax.data.res[run][i].num` + " " + self.relax.data.res[run][i].name + " of the run " + `run` 1429 return 1 1430 1431 # Accept model. 1432 return 0

1433 1434

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

1436 """Function for returning a vector of parameter names.""" 1437 1438 # Arguments 1439 self.run = run 1440 1441 # Skip residues where there is no data or errors. 1442 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not hasattr(self.relax.data.res[self.run][i], 'relax_error'): 1443 return 1444 1445 # Test if the model-free model has been setup. 1446 for j in xrange(len(self.relax.data.res[self.run])): 1447 # Skip unselected residues. 1448 if not self.relax.data.res[self.run][j].select: 1449 continue 1450 1451 # Not setup. 1452 if not self.relax.data.res[self.run][j].model: 1453 raise RelaxNoModelError, self.run 1454 1455 # Determine the parameter set type. 1456 self.param_set = self.determine_param_set_type() 1457 1458 # Residue index. 1459 if self.param_set == 'mf' or self.param_set == 'local_tm': 1460 index = i 1461 else: 1462 index = None 1463 1464 # Assemble the parameter names. 1465 self.assemble_param_names(index=index) 1466 1467 # Return the parameter names. 1468 return self.param_names

1469 1470

1471 - def get_param_values(self, run, i, sim_index=None):

1472 """Function for returning a vector of parameter values.""" 1473 1474 # Arguments 1475 self.run = run 1476 1477 # Skip residues where there is no data or errors. 1478 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not hasattr(self.relax.data.res[self.run][i], 'relax_error'): 1479 return 1480 1481 # Test if the model-free model has been setup. 1482 for j in xrange(len(self.relax.data.res[self.run])): 1483 # Skip unselected residues. 1484 if not self.relax.data.res[self.run][j].select: 1485 continue 1486 1487 # Not setup. 1488 if not self.relax.data.res[self.run][j].model: 1489 raise RelaxNoModelError, self.run 1490 1491 # Determine the parameter set type. 1492 self.param_set = self.determine_param_set_type() 1493 1494 # Residue index. 1495 if self.param_set == 'mf' or self.param_set == 'local_tm': 1496 index = i 1497 else: 1498 index = None 1499 1500 # Assemble the parameter values. 1501 self.param_vector = self.assemble_param_vector(index=index, sim_index=sim_index) 1502 1503 # Return the parameter names. 1504 return self.param_vector

1505 1506

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

1508 """The grid search function.""" 1509 1510 # Arguments. 1511 self.lower = lower 1512 self.upper = upper 1513 self.inc = inc 1514 1515 # Minimisation. 1516 self.minimise(run=run, min_algor='grid', constraints=constraints, print_flag=print_flag, sim_index=sim_index)

1517 1518

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

1520 """The grid search setup function.""" 1521 1522 # The length of the parameter array. 1523 n = len(self.param_vector) 1524 1525 # Make sure that the length of the parameter array is > 0. 1526 if n == 0: 1527 print "Cannot run a grid search on a model with zero parameters, skipping the grid search." 1528 1529 # Lower bounds. 1530 if self.lower != None: 1531 if len(self.lower) != n: 1532 raise RelaxLenError, ('lower bounds', n) 1533 1534 # Upper bounds. 1535 if self.upper != None: 1536 if len(self.upper) != n: 1537 raise RelaxLenError, ('upper bounds', n) 1538 1539 # Increment. 1540 if type(self.inc) == list: 1541 if len(self.inc) != n: 1542 raise RelaxLenError, ('increment', n) 1543 inc = self.inc 1544 elif type(self.inc) == int: 1545 temp = [] 1546 for j in xrange(n): 1547 temp.append(self.inc) 1548 inc = temp 1549 1550 # Minimisation options initialisation. 1551 min_options = [] 1552 m = 0 1553 1554 # Minimisation options for diffusion tensor parameters. 1555 if self.param_set == 'diff' or self.param_set == 'all': 1556 # Spherical diffusion {tm}. 1557 if self.relax.data.diff[self.run].type == 'sphere': 1558 min_options.append([inc[0], 1.0 * 1e-9, 12.0 * 1e-9]) 1559 m = m + 1 1560 1561 # Spheroidal diffusion {tm, Da, theta, phi}. 1562 if self.relax.data.diff[self.run].type == 'spheroid': 1563 min_options.append([inc[0], 1.0 * 1e-9, 12.0 * 1e-9]) 1564 if self.relax.data.diff[self.run].spheroid_type == 'prolate': 1565 min_options.append([inc[1], 0.0, 1e7]) 1566 elif self.relax.data.diff[self.run].spheroid_type == 'oblate': 1567 min_options.append([inc[1], -1e7, 0.0]) 1568 else: 1569 min_options.append([inc[1], -1e7, 1e7]) 1570 min_options.append([inc[2], 0.0, pi]) 1571 min_options.append([inc[3], 0.0, pi]) 1572 m = m + 4 1573 1574 # Ellipsoidal diffusion {tm, Da, Dr, alpha, beta, gamma}. 1575 elif self.relax.data.diff[self.run].type == 'ellipsoid': 1576 min_options.append([inc[0], 1.0 * 1e-9, 12.0 * 1e-9]) 1577 min_options.append([inc[1], 0.0, 1e7]) 1578 min_options.append([inc[2], 0.0, 1.0]) 1579 min_options.append([inc[3], 0.0, pi]) 1580 min_options.append([inc[4], 0.0, pi]) 1581 min_options.append([inc[5], 0.0, pi]) 1582 m = m + 6 1583 1584 # Model-free parameters (residue specific parameters). 1585 if self.param_set != 'diff': 1586 for i in xrange(len(self.relax.data.res[self.run])): 1587 # Skip unselected residues. 1588 if not self.relax.data.res[self.run][i].select: 1589 continue 1590 1591 # Only add parameters for a single residue if index has a value. 1592 if index != None and i != index: 1593 continue 1594 1595 # Loop over the model-free parameters. 1596 for j in xrange(len(self.relax.data.res[self.run][i].params)): 1597 # Local tm. 1598 if self.relax.data.res[self.run][i].params[j] == 'local_tm': 1599 min_options.append([inc[m], 1.0 * 1e-9, 12.0 * 1e-9]) 1600 1601 # {S2, S2f, S2s}. 1602 elif match('S2', self.relax.data.res[self.run][i].params[j]): 1603 min_options.append([inc[m], 0.0, 1.0]) 1604 1605 # {te, tf, ts}. 1606 elif match('t', self.relax.data.res[self.run][i].params[j]): 1607 min_options.append([inc[m], 0.0, 500.0 * 1e-12]) 1608 1609 # Rex. 1610 elif self.relax.data.res[self.run][i].params[j] == 'Rex': 1611 min_options.append([inc[m], 0.0, 5.0 / (2.0 * pi * self.relax.data.res[self.run][i].frq[0])**2]) 1612 1613 # Bond length. 1614 elif self.relax.data.res[self.run][i].params[j] == 'r': 1615 min_options.append([inc[m], 1.0 * 1e-10, 1.05 * 1e-10]) 1616 1617 # CSA. 1618 elif self.relax.data.res[self.run][i].params[j] == 'CSA': 1619 min_options.append([inc[m], -120 * 1e-6, -200 * 1e-6]) 1620 1621 # Unknown option. 1622 else: 1623 raise RelaxError, "Unknown model-free parameter." 1624 1625 # Increment m. 1626 m = m + 1 1627 1628 # Set the lower and upper bounds if these are supplied. 1629 if self.lower != None: 1630 for j in xrange(n): 1631 if self.lower[j] != None: 1632 min_options[j][1] = self.lower[j] 1633 if self.upper != None: 1634 for j in xrange(n): 1635 if self.upper[j] != None: 1636 min_options[j][2] = self.upper[j] 1637 1638 # Test if the grid is too large. 1639 self.grid_size = 1 1640 for i in xrange(len(min_options)): 1641 self.grid_size = self.grid_size * min_options[i][0] 1642 if type(self.grid_size) == long: 1643 raise RelaxError, "A grid search of size " + `self.grid_size` + " is too large." 1644 1645 # Diagonal scaling of minimisation options. 1646 for j in xrange(len(min_options)): 1647 min_options[j][1] = min_options[j][1] / self.scaling_matrix[j, j] 1648 min_options[j][2] = min_options[j][2] / self.scaling_matrix[j, j] 1649 1650 return min_options

1651 1652

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

1654 """Function for setting up the model-free linear constraint matrices A and b. 1655 1656 Standard notation 1657 ~~~~~~~~~~~~~~~~~ 1658 1659 The order parameter constraints are: 1660 1661 0 <= S2 <= 1 1662 0 <= S2f <= 1 1663 0 <= S2s <= 1 1664 1665 By substituting the formula S2 = S2f.S2s into the above inequalities, the additional two 1666 inequalities can be derived: 1667 1668 S2 <= S2f 1669 S2 <= S2s 1670 1671 Correlation time constraints are: 1672 1673 te >= 0 1674 tf >= 0 1675 ts >= 0 1676 1677 tf <= ts 1678 1679 te, tf, ts <= 2 * tm 1680 1681 Additional constraints used include: 1682 1683 Rex >= 0 1684 0.9e-10 <= r <= 2e-10 1685 -300e-6 <= CSA <= 0 1686 1687 1688 Rearranged notation 1689 ~~~~~~~~~~~~~~~~~~~ 1690 The above ineqality constraints can be rearranged into: 1691 1692 S2 >= 0 1693 -S2 >= -1 1694 S2f >= 0 1695 -S2f >= -1 1696 S2s >= 0 1697 -S2s >= -1 1698 S2f - S2 >= 0 1699 S2s - S2 >= 0 1700 te >= 0 1701 tf >= 0 1702 ts >= 0 1703 ts - tf >= 0 1704 Rex >= 0 1705 r >= 0.9e-10 1706 -r >= -2e-10 1707 CSA >= -300e-6 1708 -CSA >= 0 1709 1710 1711 Matrix notation 1712 ~~~~~~~~~~~~~~~ 1713 1714 In the notation A.x >= b, where A is an matrix of coefficients, x is an array of parameter 1715 values, and b is a vector of scalars, these inequality constraints are: 1716 1717 | 1 0 0 0 0 0 0 0 0 | | 0 | 1718 | | | | 1719 |-1 0 0 0 0 0 0 0 0 | | -1 | 1720 | | | | 1721 | 0 1 0 0 0 0 0 0 0 | | 0 | 1722 | | | | 1723 | 0 -1 0 0 0 0 0 0 0 | | -1 | 1724 | | | | 1725 | 0 0 1 0 0 0 0 0 0 | | S2 | | 0 | 1726 | | | | | | 1727 | 0 0 -1 0 0 0 0 0 0 | | S2f | | -1 | 1728 | | | | | | 1729 |-1 1 0 0 0 0 0 0 0 | | S2s | | 0 | 1730 | | | | | | 1731 |-1 0 1 0 0 0 0 0 0 | | te | | 0 | 1732 | | | | | | 1733 | 0 0 0 1 0 0 0 0 0 | . | tf | >= | 0 | 1734 | | | | | | 1735 | 0 0 0 0 1 0 0 0 0 | | ts | | 0 | 1736 | | | | | | 1737 | 0 0 0 0 0 1 0 0 0 | | Rex | | 0 | 1738 | | | | | | 1739 | 0 0 0 0 -1 1 0 0 0 | | r | | 0 | 1740 | | | | | | 1741 | 0 0 0 0 0 0 1 0 0 | | CSA | | 0 | 1742 | | | | 1743 | 0 0 0 0 0 0 0 1 0 | | 0.9e-10 | 1744 | | | | 1745 | 0 0 0 0 0 0 0 -1 0 | | -2e-10 | 1746 | | | | 1747 | 0 0 0 0 0 0 0 0 1 | | -300e-6 | 1748 | | | | 1749 | 0 0 0 0 0 0 0 0 -1 | | 0 | 1750 1751 """ 1752 1753 # Upper limit flag for correlation times. 1754 upper_time_limit = 1 1755 1756 # Initialisation (0..j..m). 1757 A = [] 1758 b = [] 1759 n = len(self.param_vector) 1760 zero_array = zeros(n, Float64) 1761 i = 0 1762 j = 0 1763 1764 # Diffusion tensor parameters. 1765 if self.param_set != 'mf' and self.relax.data.diff.has_key(self.run): 1766 # Spherical diffusion. 1767 if self.relax.data.diff[self.run].type == 'sphere': 1768 # 0 <= tm <= 200 ns. 1769 A.append(zero_array * 0.0) 1770 A.append(zero_array * 0.0) 1771 A[j][i] = 1.0 1772 A[j+1][i] = -1.0 1773 b.append(0.0 / self.scaling_matrix[i, i]) 1774 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i]) 1775 i = i + 1 1776 j = j + 2 1777 1778 # Spheroidal diffusion. 1779 elif self.relax.data.diff[self.run].type == 'spheroid': 1780 # 0 <= tm <= 200 ns. 1781 A.append(zero_array * 0.0) 1782 A.append(zero_array * 0.0) 1783 A[j][i] = 1.0 1784 A[j+1][i] = -1.0 1785 b.append(0.0 / self.scaling_matrix[i, i]) 1786 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i]) 1787 i = i + 1 1788 j = j + 2 1789 1790 # Prolate diffusion, Da >= 0. 1791 if self.relax.data.diff[self.run].spheroid_type == 'prolate': 1792 A.append(zero_array * 0.0) 1793 A[j][i] = 1.0 1794 b.append(0.0 / self.scaling_matrix[i, i]) 1795 i = i + 1 1796 j = j + 1 1797 1798 # Add two to i for the theta and phi parameters. 1799 i = i + 2 1800 1801 # Oblate diffusion, Da <= 0. 1802 elif self.relax.data.diff[self.run].spheroid_type == 'oblate': 1803 A.append(zero_array * 0.0) 1804 A[j][i] = -1.0 1805 b.append(0.0 / self.scaling_matrix[i, i]) 1806 i = i + 1 1807 j = j + 1 1808 1809 # Add two to i for the theta and phi parameters. 1810 i = i + 2 1811 1812 else: 1813 # Add three to i for the Da, theta and phi parameters. 1814 i = i + 3 1815 1816 # Ellipsoidal diffusion. 1817 elif self.relax.data.diff[self.run].type == 'ellipsoid': 1818 # 0 <= tm <= 200 ns. 1819 A.append(zero_array * 0.0) 1820 A.append(zero_array * 0.0) 1821 A[j][i] = 1.0 1822 A[j+1][i] = -1.0 1823 b.append(0.0 / self.scaling_matrix[i, i]) 1824 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i]) 1825 i = i + 1 1826 j = j + 2 1827 1828 # Da >= 0. 1829 A.append(zero_array * 0.0) 1830 A[j][i] = 1.0 1831 b.append(0.0 / self.scaling_matrix[i, i]) 1832 i = i + 1 1833 j = j + 1 1834 1835 # 0 <= Dr <= 1. 1836 A.append(zero_array * 0.0) 1837 A.append(zero_array * 0.0) 1838 A[j][i] = 1.0 1839 A[j+1][i] = -1.0 1840 b.append(0.0 / self.scaling_matrix[i, i]) 1841 b.append(-1.0 / self.scaling_matrix[i, i]) 1842 i = i + 1 1843 j = j + 2 1844 1845 # Add three to i for the alpha, beta, and gamma parameters. 1846 i = i + 3 1847 1848 # Model-free parameters. 1849 if self.param_set != 'diff': 1850 # Loop over all residues. 1851 for k in xrange(len(self.relax.data.res[self.run])): 1852 # Skip unselected residues. 1853 if not self.relax.data.res[self.run][k].select: 1854 continue 1855 1856 # Only add parameters for a single residue if index has a value. 1857 if index != None and k != index: 1858 continue 1859 1860 # Save current value of i. 1861 old_i = i 1862 1863 # Loop over the model-free parameters. 1864 for l in xrange(len(self.relax.data.res[self.run][k].params)): 1865 # Local tm. 1866 if self.relax.data.res[self.run][k].params[l] == 'local_tm': 1867 if upper_time_limit: 1868 # 0 <= tm <= 200 ns. 1869 A.append(zero_array * 0.0) 1870 A.append(zero_array * 0.0) 1871 A[j][i] = 1.0 1872 A[j+1][i] = -1.0 1873 b.append(0.0 / self.scaling_matrix[i, i]) 1874 b.append(-200.0 * 1e-9 / self.scaling_matrix[i, i]) 1875 j = j + 2 1876 else: 1877 # 0 <= tm. 1878 A.append(zero_array * 0.0) 1879 A[j][i] = 1.0 1880 b.append(0.0 / self.scaling_matrix[i, i]) 1881 j = j + 1 1882 1883 # Order parameters {S2, S2f, S2s}. 1884 elif match('S2', self.relax.data.res[self.run][k].params[l]): 1885 # 0 <= S2 <= 1. 1886 A.append(zero_array * 0.0) 1887 A.append(zero_array * 0.0) 1888 A[j][i] = 1.0 1889 A[j+1][i] = -1.0 1890 b.append(0.0 / self.scaling_matrix[i, i]) 1891 b.append(-1.0 / self.scaling_matrix[i, i]) 1892 j = j + 2 1893 1894 # S2 <= S2f and S2 <= S2s. 1895 if self.relax.data.res[self.run][k].params[l] == 'S2': 1896 for m in xrange(len(self.relax.data.res[self.run][k].params)): 1897 if self.relax.data.res[self.run][k].params[m] == 'S2f' or self.relax.data.res[self.run][k].params[m] == 'S2s': 1898 A.append(zero_array * 0.0) 1899 A[j][i] = -1.0 1900 A[j][old_i+m] = 1.0 1901 b.append(0.0) 1902 j = j + 1 1903 1904 # Correlation times {te, tf, ts}. 1905 elif match('t[efs]', self.relax.data.res[self.run][k].params[l]): 1906 # te, tf, ts >= 0. 1907 A.append(zero_array * 0.0) 1908 A[j][i] = 1.0 1909 b.append(0.0 / self.scaling_matrix[i, i]) 1910 j = j + 1 1911 1912 # tf <= ts. 1913 if self.relax.data.res[self.run][k].params[l] == 'ts': 1914 for m in xrange(len(self.relax.data.res[self.run][k].params)): 1915 if self.relax.data.res[self.run][k].params[m] == 'tf': 1916 A.append(zero_array * 0.0) 1917 A[j][i] = 1.0 1918 A[j][old_i+m] = -1.0 1919 b.append(0.0) 1920 j = j + 1 1921 1922 # te, tf, ts <= 2 * tm. (tf not needed because tf <= ts). 1923 if upper_time_limit: 1924 if not self.relax.data.res[self.run][k].params[l] == 'tf': 1925 if self.param_set == 'mf': 1926 A.append(zero_array * 0.0) 1927 A[j][i] = -1.0 1928 b.append(-2.0 * self.relax.data.diff[self.run].tm / self.scaling_matrix[i, i]) 1929 else: 1930 A.append(zero_array * 0.0) 1931 A[j][0] = 2.0 1932 A[j][i] = -1.0 1933 b.append(0.0) 1934 1935 j = j + 1 1936 1937 # Rex. 1938 elif self.relax.data.res[self.run][k].params[l] == 'Rex': 1939 A.append(zero_array * 0.0) 1940 A[j][i] = 1.0 1941 b.append(0.0 / self.scaling_matrix[i, i]) 1942 j = j + 1 1943 1944 # Bond length. 1945 elif self.relax.data.res[self.run][k].params[l] == 'r': 1946 # 0.9e-10 <= r <= 2e-10. 1947 A.append(zero_array * 0.0) 1948 A.append(zero_array * 0.0) 1949 A[j][i] = 1.0 1950 A[j+1][i] = -1.0 1951 b.append(0.9e-10 / self.scaling_matrix[i, i]) 1952 b.append(-2e-10 / self.scaling_matrix[i, i]) 1953 j = j + 2 1954 1955 # CSA. 1956 elif self.relax.data.res[self.run][k].params[l] == 'CSA': 1957 # -300e-6 <= CSA <= 0. 1958 A.append(zero_array * 0.0) 1959 A.append(zero_array * 0.0) 1960 A[j][i] = 1.0 1961 A[j+1][i] = -1.0 1962 b.append(-300e-6 / self.scaling_matrix[i, i]) 1963 b.append(0.0 / self.scaling_matrix[i, i]) 1964 j = j + 2 1965 1966 # Increment i. 1967 i = i + 1 1968 1969 # Convert to Numeric data structures. 1970 A = array(A, Float64) 1971 b = array(b, Float64) 1972 1973 return A, b

1974 1975

1976 - def map_bounds(self, run, param):

1977 """The function for creating bounds for the mapping function.""" 1978 1979 # Arguments. 1980 self.run = run 1981 1982 # {S2, S2f, S2s}. 1983 if search('^s2', param): 1984 return [0, 1] 1985 1986 # {local tm, te, tf, ts}. 1987 elif search('^t', param) or param == 'local_tm': 1988 return [0, 1e-8] 1989 1990 # Rex. 1991 elif param == 'rex': 1992 return [0, 30.0 / (2.0 * pi * self.relax.data.frq[self.run][0])**2] 1993 1994 # Bond length. 1995 elif param == 'r': 1996 return [1.0 * 1e-10, 1.1 * 1e-10] 1997 1998 # CSA. 1999 elif param == 'csa': 2000 return [-100 * 1e-6, -300 * 1e-6]

2001 2002

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

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

2481 2482

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

2484 """Function for updating various data structures depending on the model selected.""" 2485 2486 # Test that no diffusion tensor exists for the run if local tm is a parameter in the model. 2487 if params: 2488 for param in params: 2489 if param == 'local_tm' and self.relax.data.diff.has_key(run): 2490 raise RelaxTensorError, run 2491 2492 # Loop over the sequence. 2493 for i in xrange(len(self.relax.data.res[run])): 2494 # If res_num is set, then skip all other residues. 2495 if res_num != None and res_num != self.relax.data.res[run][i].num: 2496 continue 2497 2498 # Initialise the data structures (if needed). 2499 self.data_init(self.relax.data.res[run][i]) 2500 2501 # Model-free model, equation, and parameter types. 2502 if model: 2503 self.relax.data.res[run][i].model = model 2504 if equation: 2505 self.relax.data.res[run][i].equation = equation 2506 if params: 2507 self.relax.data.res[run][i].params = params

2508 2509

2510 - def model_statistics(self, run=None, instance=None, global_stats=None):

2511 """Function for returning k, n, and chi2. 2512 2513 k - number of parameters. 2514 n - number of data points. 2515 chi2 - the chi-squared value. 2516 """ 2517 2518 # Arguments. 2519 self.run = run 2520 2521 # Determine if local or global statistics will be returned. 2522 if global_stats == None: 2523 global_stats = 1 2524 for i in xrange(len(self.relax.data.res[self.run])): 2525 if hasattr(self.relax.data.res[self.run][i], 'chi2') and self.relax.data.res[self.run][i].chi2 != None: 2526 global_stats = 0 2527 break 2528 2529 # Determine the parameter set type. 2530 self.param_set = self.determine_param_set_type() 2531 2532 # Statistics for a single residue. 2533 if not global_stats: 2534 # Skip unselected residues. 2535 if not self.relax.data.res[self.run][instance].select: 2536 return None, None, None 2537 2538 # Missing data sets. 2539 if not hasattr(self.relax.data.res[self.run][instance], 'relax_data'): 2540 return None, None, None 2541 2542 # Count the number of parameters. 2543 self.param_vector = self.assemble_param_vector(index=instance) 2544 k = len(self.param_vector) 2545 2546 # Count the number of data points. 2547 n = len(self.relax.data.res[self.run][instance].relax_data) 2548 2549 # The chi2 value. 2550 chi2 = self.relax.data.res[self.run][instance].chi2 2551 2552 # Global stats. 2553 elif global_stats: 2554 # Count the number of parameters. 2555 self.param_vector = self.assemble_param_vector() 2556 k = len(self.param_vector) 2557 2558 # Count the number of data points. 2559 n = 0 2560 chi2 = 0 2561 for i in xrange(len(self.relax.data.res[self.run])): 2562 # Skip unselected residues. 2563 if not self.relax.data.res[self.run][i].select: 2564 continue 2565 2566 # Skip residues with no relaxation data. 2567 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not len(self.relax.data.res[self.run][i].relax_data): 2568 continue 2569 2570 n = n + len(self.relax.data.res[self.run][i].relax_data) 2571 2572 # Local tm models. 2573 if self.param_set == 'local_tm': 2574 chi2 = chi2 + self.relax.data.res[self.run][i].chi2 2575 2576 # The chi2 value. 2577 if self.param_set != 'local_tm': 2578 chi2 = self.relax.data.chi2[self.run] 2579 2580 # Return the data. 2581 return k, n, chi2

2582 2583

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

2585 """Function for returning the number of instances.""" 2586 2587 # Arguments. 2588 self.run = run 2589 2590 # Test if sequence data is loaded. 2591 if not self.relax.data.res.has_key(self.run): 2592 return 0 2593 2594 # Determine the parameter set type. 2595 self.param_set = self.determine_param_set_type() 2596 2597 # Sequence specific data. 2598 if self.param_set == 'mf' or self.param_set == 'local_tm': 2599 return len(self.relax.data.res[self.run]) 2600 2601 # Other data. 2602 elif self.param_set == 'diff' or self.param_set == 'all': 2603 return 1 2604 2605 # Should not be here. 2606 else: 2607 raise RelaxFault

2608 2609

2610 - def overfit_deselect(self, run):

2611 """Function for deselecting residues without sufficient data to support minimisation""" 2612 2613 # Test sequence data exists. 2614 if not self.relax.data.res.has_key(run): 2615 raise RelaxNoSequenceError, run 2616 2617 # Loop over residue data: 2618 for residue in self.relax.data.res[run]: 2619 # Skip unselected data: 2620 if not residue.select: 2621 continue 2622 2623 # Check for data structure. 2624 if not hasattr(residue, 'relax_data'): 2625 residue.select = 0 2626 continue 2627 2628 # Require 3 or more data points 2629 if len(residue.relax_data) < 3: 2630 residue.select = 0 2631 continue 2632 2633 # Require at least as many data points as params to prevent over-fitting 2634 if hasattr(residue, 'params'): 2635 if len(residue.params) > len(residue.relax_data): 2636 residue.select = 0 2637 continue 2638 2639 # Test for structural data if required 2640 if hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(run): 2641 if self.relax.data.diff[run].type == 'spheroid' or self.relax.data.diff[run].type == 'ellipsoid': 2642 if not hasattr(residue, 'xh_vect'): 2643 residue.select = 0 2644 continue

2645 2646

2647 - def read_columnar_col_numbers(self, header):

2648 """Function for sorting the column numbers from the columnar formatted results file.""" 2649 2650 # Initialise the hash. 2651 self.col = {} 2652 2653 # Loop over the columns. 2654 for i in xrange(len(header)): 2655 # Residue info. 2656 if header[i] == 'Num': 2657 self.col['num'] = i 2658 elif header[i] == 'Name': 2659 self.col['name'] = i 2660 elif header[i] == 'Selected': 2661 self.col['select'] = i 2662 elif header[i] == 'Data_set': 2663 self.col['data_set'] = i 2664 elif header[i] == 'Nucleus': 2665 self.col['nucleus'] = i 2666 elif header[i] == 'Model': 2667 self.col['model'] = i 2668 elif header[i] == 'Equation': 2669 self.col['eqi'] = i 2670 elif header[i] == 'Params': 2671 self.col['params'] = i 2672 elif header[i] == 'Param_set': 2673 self.col['param_set'] = i 2674 2675 # Parameters. 2676 elif header[i] == 'S2': 2677 self.col['s2'] = i 2678 elif header[i] == 'S2f': 2679 self.col['s2f'] = i 2680 elif header[i] == 'S2s': 2681 self.col['s2s'] = i 2682 elif search('^Local_tm', header[i]): 2683 self.col['local_tm'] = i 2684 elif search('^te', header[i]): 2685 self.col['te'] = i 2686 elif search('^tf', header[i]): 2687 self.col['tf'] = i 2688 elif search('^ts', header[i]): 2689 self.col['ts'] = i 2690 elif search('^Rex', header[i]): 2691 self.col['rex'] = i 2692 elif search('^Bond_length', header[i]): 2693 self.col['r'] = i 2694 elif search('^CSA', header[i]): 2695 self.col['csa'] = i 2696 2697 # Minimisation info. 2698 elif header[i] == 'Chi-squared': 2699 self.col['chi2'] = i 2700 elif header[i] == 'Iter': 2701 self.col['iter'] = i 2702 elif header[i] == 'f_count': 2703 self.col['f_count'] = i 2704 elif header[i] == 'g_count': 2705 self.col['g_count'] = i 2706 elif header[i] == 'h_count': 2707 self.col['h_count'] = i 2708 elif header[i] == 'Warning': 2709 self.col['warn'] = i 2710 2711 # Diffusion tensor. 2712 elif header[i] == 'Diff_type': 2713 self.col['diff_type'] = i 2714 elif header[i] == 'tm_(s)': 2715 self.col['tm'] = i 2716 elif header[i] == 'Da_(1/s)': 2717 self.col['da'] = i 2718 elif header[i] == 'theta_(deg)': 2719 self.col['theta'] = i 2720 elif header[i] == 'phi_(deg)': 2721 self.col['phi'] = i 2722 elif header[i] == 'Da_(1/s)': 2723 self.col['da'] = i 2724 elif header[i] == 'Dr_(1/s)': 2725 self.col['dr'] = i 2726 elif header[i] == 'alpha_(deg)': 2727 self.col['alpha'] = i 2728 elif header[i] == 'beta_(deg)': 2729 self.col['beta'] = i 2730 elif header[i] == 'gamma_(deg)': 2731 self.col['gamma'] = i 2732 2733 # PDB and XH vector. 2734 elif header[i] == 'PDB': 2735 self.col['pdb'] = i 2736 elif header[i] == 'PDB_model': 2737 self.col['pdb_model'] = i 2738 elif header[i] == 'PDB_heteronuc': 2739 self.col['pdb_heteronuc'] = i 2740 elif header[i] == 'PDB_proton': 2741 self.col['pdb_proton'] = i 2742 elif header[i] == 'XH_vector': 2743 self.col['xh_vect'] = i 2744 2745 # Relaxation data. 2746 elif header[i] == 'Ri_labels': 2747 self.col['ri_labels'] = i 2748 elif header[i] == 'Remap_table': 2749 self.col['remap_table'] = i 2750 elif header[i] == 'Frq_labels': 2751 self.col['frq_labels'] = i 2752 elif header[i] == 'Frequencies': 2753 self.col['frq'] = i

2754 2755

2756 - def read_columnar_diff_tensor(self):

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

2906 2907

2908 - def read_columnar_find_index(self):

2909 """Function for generating the sequence and or returning the residue index.""" 2910 2911 # Residue number and name. 2912 try: 2913 self.res_num = int(self.file_line[self.col['num']]) 2914 except ValueError: 2915 raise RelaxError, "The residue number " + self.file_line[self.col['num']] + " is not an integer." 2916 self.res_name = self.file_line[self.col['name']] 2917 2918 # Find the residue index. 2919 res_index = None 2920 for j in xrange(len(self.relax.data.res[self.run])): 2921 if self.relax.data.res[self.run][j].num == self.res_num and self.relax.data.res[self.run][j].name == self.res_name: 2922 res_index = j 2923 break 2924 if res_index == None: 2925 raise RelaxError, "Residue " + `self.res_num` + " " + self.res_name + " cannot be found in the sequence." 2926 2927 # Return the index. 2928 return res_index

2929 2930

2931 - def read_columnar_model_free_data(self):

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

3221 3222

3223 - def read_columnar_param_set(self):

3224 """Function for reading the parameter set.""" 3225 3226 # Extract the parameter set if it exists, otherwise return. 3227 if self.file_line[self.col['param_set']] != 'None': 3228 self.param_set = self.file_line[self.col['param_set']] 3229 else: 3230 return 3231 3232 # Local tm and model-free only parameter sets. 3233 if self.param_set == 'local_tm' or self.param_set == 'mf': 3234 diff_fixed = 1 3235 res_fixed = 0 3236 3237 # Diffusion tensor parameter set. 3238 elif self.param_set == 'diff': 3239 diff_fixed = 0 3240 res_fixed = 1 3241 3242 # 'all' parameter set. 3243 elif self.param_set == 'all': 3244 diff_fixed = 0 3245 res_fixed = 0 3246 3247 # No parameter set. 3248 elif self.param_set == 'None': 3249 self.param_set = None 3250 diff_fixed = None 3251 res_fixed = None 3252 3253 # Set the diffusion tensor fixed flag. 3254 if self.param_set != 'local_tm' and diff_fixed != None: 3255 self.relax.data.diff[self.run].fixed = diff_fixed 3256 3257 # Set the residue specific fixed flag. 3258 for i in xrange(len(self.relax.data.res[self.run])): 3259 if res_fixed != None: 3260 self.relax.data.res[self.run][i].fixed = res_fixed

3261 3262

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

3264 """Function for reading the PDB file.""" 3265 3266 # File name. 3267 pdb = self.file_line[self.col['pdb']] 3268 3269 # PDB model. 3270 pdb_model = eval(self.file_line[self.col['pdb_model']]) 3271 3272 # Heteronucleus. 3273 if self.col.has_key('pdb_heteronuc'): 3274 pdb_heteronuc = self.file_line[self.col['pdb_heteronuc']] 3275 3276 # Proton. 3277 if self.col.has_key('pdb_proton'): 3278 pdb_proton = self.file_line[self.col['pdb_proton']] 3279 3280 # Load the PDB. 3281 if not pdb == 'None': 3282 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) 3283 return 1 3284 else: 3285 return 0

3286 3287

3288 - def read_columnar_relax_data(self):

3289 """Function for reading the relaxation data.""" 3290 3291 # Skip the error 'data_set'. 3292 if self.data_set == 'error': 3293 return 3294 3295 # Relaxation data structures. 3296 self.ri_labels = eval(self.file_line[self.col['ri_labels']]) 3297 self.remap_table = eval(self.file_line[self.col['remap_table']]) 3298 self.frq_labels = eval(self.file_line[self.col['frq_labels']]) 3299 self.frq = eval(self.file_line[self.col['frq']]) 3300 3301 # No relaxation data. 3302 if not self.ri_labels: 3303 return 3304 3305 # Initialise the value and error arrays. 3306 values = [] 3307 errors = [] 3308 3309 # Loop over the relaxation data of the residue. 3310 for i in xrange(len(self.ri_labels)): 3311 # Determine the data and error columns for this relaxation data set. 3312 data_col = self.col['frq'] + i + 1 3313 error_col = self.col['frq'] + len(self.ri_labels) + i + 1 3314 3315 # Append the value and error. 3316 values.append(eval(self.file_line[data_col])) 3317 errors.append(eval(self.file_line[error_col])) 3318 3319 # Simulations. 3320 sim = 0 3321 if self.data_set != 'value' and self.data_set != 'error': 3322 sim = 1 3323 3324 # Add the relaxation data. 3325 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)

3326 3327

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

3329 """Function for reading the results file.""" 3330 3331 # Arguments. 3332 self.run = run 3333 3334 # Extract and remove the header. 3335 header = file_data[0] 3336 file_data = file_data[1:] 3337 3338 # Sort the column numbers. 3339 self.read_columnar_col_numbers(header) 3340 3341 # Test the file. 3342 if len(self.col) < 2: 3343 raise RelaxInvalidDataError 3344 3345 # Initialise some data structures and flags. 3346 nucleus_set = 0 3347 sim_num = None 3348 sims = [] 3349 all_select_sim = [] 3350 diff_data_set = 0 3351 diff_error_set = 0 3352 diff_sim_set = None 3353 self.param_set = None 3354 pdb = 0 3355 pdb_model = None 3356 pdb_heteronuc = None 3357 pdb_proton = None 3358 self.ri_labels = None 3359 3360 # Generate the sequence. 3361 for self.file_line in file_data: 3362 # The data set. 3363 self.data_set = self.file_line[self.col['data_set']] 3364 3365 # Stop creating the sequence once the data_set is no longer 'value'. 3366 if self.data_set != 'value': 3367 break 3368 3369 # Sequence. 3370 self.read_columnar_sequence() 3371 3372 3373 # Loop over the lines of the file data. 3374 for self.file_line in file_data: 3375 # The data set. 3376 self.data_set = self.file_line[self.col['data_set']] 3377 3378 # Find the residue index. 3379 self.res_index = self.read_columnar_find_index() 3380 3381 # Reassign data structure. 3382 data = self.relax.data.res[self.run][self.res_index] 3383 3384 # Backwards compatibility for the reading of the results file from versions 1.2.0 to 1.2.9. 3385 if len(self.file_line) == 4: 3386 continue 3387 3388 # Set the nucleus type. 3389 if not nucleus_set: 3390 if self.file_line[self.col['nucleus']] != 'None': 3391 self.relax.generic.nuclei.set_values(self.file_line[self.col['nucleus']]) 3392 nucleus_set = 1 3393 3394 # Simulation number. 3395 if self.data_set != 'value' and self.data_set != 'error': 3396 # Extract the number from the self.data_set string. 3397 sim_num = split(self.data_set, '_') 3398 try: 3399 sim_num = int(sim_num[1]) 3400 except: 3401 raise RelaxError, "The simulation number '%s' is invalid." % sim_num 3402 3403 # A new simulation number. 3404 if sim_num not in sims: 3405 # Update the sims array and append an empty array to the selected sims array. 3406 sims.append(sim_num) 3407 all_select_sim.append([]) 3408 3409 # Selected simulations. 3410 all_select_sim[-1].append(int(self.file_line[self.col['select']])) 3411 3412 # Diffusion tensor data. 3413 if self.data_set == 'value' and not diff_data_set: 3414 self.read_columnar_diff_tensor() 3415 diff_data_set = 1 3416 3417 # Diffusion tensor errors. 3418 elif self.data_set == 'error' and not diff_error_set: 3419 self.read_columnar_diff_tensor() 3420 diff_error_set = 1 3421 3422 # Diffusion tensor simulation data. 3423 elif self.data_set != 'value' and self.data_set != 'error' and sim_num != diff_sim_set: 3424 self.read_columnar_diff_tensor() 3425 diff_sim_set = sim_num 3426 3427 # Parameter set. 3428 if self.param_set == None: 3429 self.read_columnar_param_set() 3430 3431 # PDB. 3432 if not pdb: 3433 if self.read_columnar_pdb(print_flag): 3434 pdb = 1 3435 3436 # XH vector, heteronucleus, and proton. 3437 if self.data_set == 'value': 3438 self.read_columnar_xh_vect() 3439 3440 # Relaxation data. 3441 self.read_columnar_relax_data() 3442 3443 # Model-free data. 3444 self.read_columnar_model_free_data() 3445 3446 # Set up the simulations. 3447 if len(sims): 3448 # Convert the selected simulation array of arrays into a Numeric matrix and transpose it. 3449 all_select_sim = transpose(array(all_select_sim)) 3450 3451 # Set up the Monte Carlo simulations. 3452 self.relax.generic.monte_carlo.setup(self.run, number=len(sims), all_select_sim=all_select_sim) 3453 3454 # Turn the simulation state to off! 3455 self.relax.data.sim_state[self.run] = 0

3456 3457

3458 - def read_columnar_sequence(self):

3459 """Function for generating the sequence.""" 3460 3461 # Residue number and name. 3462 try: 3463 res_num = int(self.file_line[self.col['num']]) 3464 except ValueError: 3465 raise RelaxError, "The residue number " + self.file_line[self.col['num']] + " is not an integer." 3466 res_name = self.file_line[self.col['name']] 3467 3468 # Generate the sequence. 3469 self.relax.generic.sequence.add(self.run, res_num, res_name, select=int(self.file_line[self.col['select']]))

3470 3471

3472 - def read_columnar_xh_vect(self):

3473 """Function for reading the XH unit vectors.""" 3474 3475 # The vector. 3476 xh_vect = eval(self.file_line[self.col['xh_vect']]) 3477 if xh_vect: 3478 # Numeric array format. 3479 try: 3480 xh_vect = array(xh_vect, Float64) 3481 except: 3482 raise RelaxError, "The XH unit vector " + self.file_line[self.col['xh_vect']] + " is invalid." 3483 3484 # Set the vector. 3485 self.relax.generic.pdb.set_vector(run=self.run, res=self.res_index, xh_vect=xh_vect) 3486 3487 # The heteronucleus and proton names. 3488 self.relax.data.res[self.run][self.res_index].heteronuc = self.file_line[self.col['pdb_heteronuc']] 3489 self.relax.data.res[self.run][self.res_index].proton = self.file_line[self.col['pdb_proton']]

3490 3491

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

3493 """Function for removing the local tm parameter from the model-free parameters.""" 3494 3495 # Arguments. 3496 self.run = run 3497 3498 # Test if the run exists. 3499 if not self.run in self.relax.data.run_names: 3500 raise RelaxNoRunError, self.run 3501 3502 # Test if the run type is set to 'mf'. 3503 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 3504 if function_type != 'mf': 3505 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 3506 3507 # Test if sequence data is loaded. 3508 if not self.relax.data.res.has_key(self.run): 3509 raise RelaxNoSequenceError, self.run 3510 3511 # Loop over the sequence. 3512 for i in xrange(len(self.relax.data.res[self.run])): 3513 # Remap the data structure. 3514 data = self.relax.data.res[self.run][i] 3515 3516 # Skip unselected residues. 3517 if not data.select: 3518 continue 3519 3520 # If res_num is set, then skip all other residues. 3521 if res_num != None and res_num != data.num: 3522 continue 3523 3524 # Test if a local tm parameter exists. 3525 if not hasattr(data, 'params') or not 'local_tm' in data.params: 3526 continue 3527 3528 # Remove tm. 3529 data.params.remove('local_tm') 3530 3531 # Model name. 3532 if match('^tm', data.model): 3533 data.model = data.model[1:] 3534 3535 # Set the local tm value to None. 3536 data.local_tm = None 3537 3538 # Set all the minimisation details to None. 3539 data.chi2 = None 3540 data.iter = None 3541 data.f_count = None 3542 data.g_count = None 3543 data.h_count = None 3544 data.warning = None 3545 3546 # Set the global minimisation details to None. 3547 self.relax.data.chi2[self.run] = None 3548 self.relax.data.iter[self.run] = None 3549 self.relax.data.f_count[self.run] = None 3550 self.relax.data.g_count[self.run] = None 3551 self.relax.data.h_count[self.run] = None 3552 self.relax.data.warning[self.run] = None

3553 3554

3555 - def return_conversion_factor(self, param):

3556 """Function for returning the factor of conversion between different parameter units. 3557 3558 For example, the internal representation of te is in seconds, whereas the external 3559 representation is in picoseconds, therefore this function will return 1e-12 for te. 3560 """ 3561 3562 # Get the object name. 3563 object_name = self.return_data_name(param) 3564 3565 # tm (nanoseconds). 3566 if object_name == 'tm' or object_name == 'local_tm': 3567 return 1e-9 3568 3569 # te, tf, and ts (picoseconds). 3570 elif object_name in ['te', 'tf', 'ts']: 3571 return 1e-12 3572 3573 # Rex (value at 1st field strength). 3574 elif object_name == 'rex': 3575 return 1.0 / (2.0 * pi * self.relax.data.frq[self.run][0])**2 3576 3577 # Bond length (Angstrom). 3578 elif object_name == 'r': 3579 return 1e-10 3580 3581 # CSA (ppm). 3582 elif object_name == 'csa': 3583 return 1e-6 3584 3585 # No conversion factor. 3586 else: 3587 return 1.0

3588 3589

3590 - def return_data_name(self, name):

3591 """ 3592 Model-free data type string matching patterns 3593 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 3594 3595 ____________________________________________________________________________________________ 3596 | | | | 3597 | Data type | Object name | Patterns | 3598 |________________________|______________|__________________________________________________| 3599 | | | | 3600 | Local tm | 'local_tm' | '[Ll]ocal[ -_]tm' | 3601 | | | | 3602 | Order parameter S2 | 's2' | '^[Ss]2$' | 3603 | | | | 3604 | Order parameter S2f | 's2f' | '^[Ss]2f$' | 3605 | | | | 3606 | Order parameter S2s | 's2s' | '^[Ss]2s$' | 3607 | | | | 3608 | Correlation time te | 'te' | '^te$' | 3609 | | | | 3610 | Correlation time tf | 'tf' | '^tf$' | 3611 | | | | 3612 | Correlation time ts | 'ts' | '^ts$' | 3613 | | | | 3614 | Chemical exchange | 'rex' | '^[Rr]ex$' or '[Cc]emical[ -_][Ee]xchange' | 3615 | | | | 3616 | Bond length | 'r' | '^r$' or '[Bb]ond[ -_][Ll]ength' | 3617 | | | | 3618 | CSA | 'csa' | '^[Cc][Ss][Aa]$' | 3619 |________________________|______________|__________________________________________________| 3620 3621 """ 3622 3623 # Local tm. 3624 if search('[Ll]ocal[ -_]tm', name): 3625 return 'local_tm' 3626 3627 # Order parameter S2. 3628 if search('^[Ss]2$', name): 3629 return 's2' 3630 3631 # Order parameter S2f. 3632 if search('^[Ss]2f$', name): 3633 return 's2f' 3634 3635 # Order parameter S2s. 3636 if search('^[Ss]2s$', name): 3637 return 's2s' 3638 3639 # Correlation time te. 3640 if search('^te$', name): 3641 return 'te' 3642 3643 # Correlation time tf. 3644 if search('^tf$', name): 3645 return 'tf' 3646 3647 # Correlation time ts. 3648 if search('^ts$', name): 3649 return 'ts' 3650 3651 # Rex. 3652 if search('^[Rr]ex$', name) or search('[Cc]emical[ -_][Ee]xchange', name): 3653 return 'rex' 3654 3655 # Bond length. 3656 if search('^r$', name) or search('[Bb]ond[ -_][Ll]ength', name): 3657 return 'r' 3658 3659 # CSA. 3660 if search('^[Cc][Ss][Aa]$', name): 3661 return 'csa'

3662 3663

3664 - def return_grace_string(self, param):

3665 """Function for returning the Grace string representing the parameter for axis labelling.""" 3666 3667 # Get the object name. 3668 object_name = self.return_data_name(param) 3669 3670 # Local tm. 3671 if object_name == 'tm' or object_name == 'local_tm': 3672 return '\\xt\\f{}\\sm' 3673 3674 # Order parameter S2. 3675 elif object_name == 's2': 3676 return '\\qS\\v{0.4}\\z{0.71}2\\Q' 3677 3678 # Order parameter S2f. 3679 elif object_name == 's2f': 3680 return '\\qS\\sf\\N\\h{-0.2}\\v{0.4}\\z{0.71}2\\Q' 3681 3682 # Order parameter S2s. 3683 elif object_name == 's2s': 3684 return '\\qS\\ss\\N\\h{-0.2}\\v{0.4}\\z{0.71}2\\Q' 3685 3686 # Correlation time te. 3687 elif object_name == 'te': 3688 return '\\xt\\f{}\\se' 3689 3690 # Correlation time tf. 3691 elif object_name == 'tf': 3692 return '\\xt\\f{}\\sf' 3693 3694 # Correlation time ts. 3695 elif object_name == 'ts': 3696 return '\\xt\\f{}\\ss' 3697 3698 # Rex. 3699 elif object_name == 'rex': 3700 return '\\qR\\sex\\Q' 3701 3702 # Bond length. 3703 elif object_name == 'r': 3704 return 'Bond length' 3705 3706 # CSA. 3707 elif object_name == 'csa': 3708 return '\\qCSA\\Q'

3709 3710

3711 - def return_units(self, param):

3712 """Function for returning a string representing the parameters units. 3713 3714 For example, the internal representation of te is in seconds, whereas the external 3715 representation is in picoseconds, therefore this function will return the string 3716 'picoseconds' for te. 3717 """ 3718 3719 # Get the object name. 3720 object_name = self.return_data_name(param) 3721 3722 # tm (nanoseconds). 3723 if object_name == 'tm' or object_name == 'local_tm': 3724 return 'ns' 3725 3726 # te, tf, and ts (picoseconds). 3727 elif object_name in ['te', 'tf', 'ts']: 3728 return 'ps' 3729 3730 # Rex (value at 1st field strength). 3731 elif object_name == 'rex': 3732 return self.relax.data.frq_labels[self.run][0] + ' MHz' 3733 3734 # Bond length (Angstrom). 3735 elif object_name == 'r': 3736 return 'Angstrom' 3737 3738 # CSA (ppm). 3739 elif object_name == 'csa': 3740 return 'ppm'

3741 3742

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

3744 """Function for the selection of a preset model-free model.""" 3745 3746 # Arguments. 3747 self.run = run 3748 3749 # Test if the run exists. 3750 if not self.run in self.relax.data.run_names: 3751 raise RelaxNoRunError, self.run 3752 3753 # Test if the run type is set to 'mf'. 3754 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 3755 if function_type != 'mf': 3756 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 3757 3758 # Test if sequence data is loaded. 3759 if not self.relax.data.res.has_key(self.run): 3760 raise RelaxNoSequenceError, self.run 3761 3762 3763 # Preset models. 3764 ################ 3765 3766 # Block 1. 3767 if model == 'm0': 3768 equation = 'mf_orig' 3769 params = [] 3770 elif model == 'm1': 3771 equation = 'mf_orig' 3772 params = ['S2'] 3773 elif model == 'm2': 3774 equation = 'mf_orig' 3775 params = ['S2', 'te'] 3776 elif model == 'm3': 3777 equation = 'mf_orig' 3778 params = ['S2', 'Rex'] 3779 elif model == 'm4': 3780 equation = 'mf_orig' 3781 params = ['S2', 'te', 'Rex'] 3782 elif model == 'm5': 3783 equation = 'mf_ext' 3784 params = ['S2f', 'S2', 'ts'] 3785 elif model == 'm6': 3786 equation = 'mf_ext' 3787 params = ['S2f', 'tf', 'S2', 'ts'] 3788 elif model == 'm7': 3789 equation = 'mf_ext' 3790 params = ['S2f', 'S2', 'ts', 'Rex'] 3791 elif model == 'm8': 3792 equation = 'mf_ext' 3793 params = ['S2f', 'tf', 'S2', 'ts', 'Rex'] 3794 elif model == 'm9': 3795 equation = 'mf_orig' 3796 params = ['Rex'] 3797 3798 # Block 2. 3799 elif model == 'm10': 3800 equation = 'mf_orig' 3801 params = ['CSA'] 3802 elif model == 'm11': 3803 equation = 'mf_orig' 3804 params = ['CSA', 'S2'] 3805 elif model == 'm12': 3806 equation = 'mf_orig' 3807 params = ['CSA', 'S2', 'te'] 3808 elif model == 'm13': 3809 equation = 'mf_orig' 3810 params = ['CSA', 'S2', 'Rex'] 3811 elif model == 'm14': 3812 equation = 'mf_orig' 3813 params = ['CSA', 'S2', 'te', 'Rex'] 3814 elif model == 'm15': 3815 equation = 'mf_ext' 3816 params = ['CSA', 'S2f', 'S2', 'ts'] 3817 elif model == 'm16': 3818 equation = 'mf_ext' 3819 params = ['CSA', 'S2f', 'tf', 'S2', 'ts'] 3820 elif model == 'm17': 3821 equation = 'mf_ext' 3822 params = ['CSA', 'S2f', 'S2', 'ts', 'Rex'] 3823 elif model == 'm18': 3824 equation = 'mf_ext' 3825 params = ['CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3826 elif model == 'm19': 3827 equation = 'mf_orig' 3828 params = ['CSA', 'Rex'] 3829 3830 # Block 3. 3831 elif model == 'm20': 3832 equation = 'mf_orig' 3833 params = ['r'] 3834 elif model == 'm21': 3835 equation = 'mf_orig' 3836 params = ['r', 'S2'] 3837 elif model == 'm22': 3838 equation = 'mf_orig' 3839 params = ['r', 'S2', 'te'] 3840 elif model == 'm23': 3841 equation = 'mf_orig' 3842 params = ['r', 'S2', 'Rex'] 3843 elif model == 'm24': 3844 equation = 'mf_orig' 3845 params = ['r', 'S2', 'te', 'Rex'] 3846 elif model == 'm25': 3847 equation = 'mf_ext' 3848 params = ['r', 'S2f', 'S2', 'ts'] 3849 elif model == 'm26': 3850 equation = 'mf_ext' 3851 params = ['r', 'S2f', 'tf', 'S2', 'ts'] 3852 elif model == 'm27': 3853 equation = 'mf_ext' 3854 params = ['r', 'S2f', 'S2', 'ts', 'Rex'] 3855 elif model == 'm28': 3856 equation = 'mf_ext' 3857 params = ['r', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3858 elif model == 'm29': 3859 equation = 'mf_orig' 3860 params = ['r', 'Rex'] 3861 3862 # Block 4. 3863 elif model == 'm30': 3864 equation = 'mf_orig' 3865 params = ['r', 'CSA'] 3866 elif model == 'm31': 3867 equation = 'mf_orig' 3868 params = ['r', 'CSA', 'S2'] 3869 elif model == 'm32': 3870 equation = 'mf_orig' 3871 params = ['r', 'CSA', 'S2', 'te'] 3872 elif model == 'm33': 3873 equation = 'mf_orig' 3874 params = ['r', 'CSA', 'S2', 'Rex'] 3875 elif model == 'm34': 3876 equation = 'mf_orig' 3877 params = ['r', 'CSA', 'S2', 'te', 'Rex'] 3878 elif model == 'm35': 3879 equation = 'mf_ext' 3880 params = ['r', 'CSA', 'S2f', 'S2', 'ts'] 3881 elif model == 'm36': 3882 equation = 'mf_ext' 3883 params = ['r', 'CSA', 'S2f', 'tf', 'S2', 'ts'] 3884 elif model == 'm37': 3885 equation = 'mf_ext' 3886 params = ['r', 'CSA', 'S2f', 'S2', 'ts', 'Rex'] 3887 elif model == 'm38': 3888 equation = 'mf_ext' 3889 params = ['r', 'CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3890 elif model == 'm39': 3891 equation = 'mf_orig' 3892 params = ['r', 'CSA', 'Rex'] 3893 3894 3895 # Preset models with local correlation time. 3896 ############################################ 3897 3898 # Block 1. 3899 elif model == 'tm0': 3900 equation = 'mf_orig' 3901 params = ['local_tm'] 3902 elif model == 'tm1': 3903 equation = 'mf_orig' 3904 params = ['local_tm', 'S2'] 3905 elif model == 'tm2': 3906 equation = 'mf_orig' 3907 params = ['local_tm', 'S2', 'te'] 3908 elif model == 'tm3': 3909 equation = 'mf_orig' 3910 params = ['local_tm', 'S2', 'Rex'] 3911 elif model == 'tm4': 3912 equation = 'mf_orig' 3913 params = ['local_tm', 'S2', 'te', 'Rex'] 3914 elif model == 'tm5': 3915 equation = 'mf_ext' 3916 params = ['local_tm', 'S2f', 'S2', 'ts'] 3917 elif model == 'tm6': 3918 equation = 'mf_ext' 3919 params = ['local_tm', 'S2f', 'tf', 'S2', 'ts'] 3920 elif model == 'tm7': 3921 equation = 'mf_ext' 3922 params = ['local_tm', 'S2f', 'S2', 'ts', 'Rex'] 3923 elif model == 'tm8': 3924 equation = 'mf_ext' 3925 params = ['local_tm', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3926 elif model == 'tm9': 3927 equation = 'mf_orig' 3928 params = ['local_tm', 'Rex'] 3929 3930 # Block 2. 3931 elif model == 'tm10': 3932 equation = 'mf_orig' 3933 params = ['local_tm', 'CSA'] 3934 elif model == 'tm11': 3935 equation = 'mf_orig' 3936 params = ['local_tm', 'CSA', 'S2'] 3937 elif model == 'tm12': 3938 equation = 'mf_orig' 3939 params = ['local_tm', 'CSA', 'S2', 'te'] 3940 elif model == 'tm13': 3941 equation = 'mf_orig' 3942 params = ['local_tm', 'CSA', 'S2', 'Rex'] 3943 elif model == 'tm14': 3944 equation = 'mf_orig' 3945 params = ['local_tm', 'CSA', 'S2', 'te', 'Rex'] 3946 elif model == 'tm15': 3947 equation = 'mf_ext' 3948 params = ['local_tm', 'CSA', 'S2f', 'S2', 'ts'] 3949 elif model == 'tm16': 3950 equation = 'mf_ext' 3951 params = ['local_tm', 'CSA', 'S2f', 'tf', 'S2', 'ts'] 3952 elif model == 'tm17': 3953 equation = 'mf_ext' 3954 params = ['local_tm', 'CSA', 'S2f', 'S2', 'ts', 'Rex'] 3955 elif model == 'tm18': 3956 equation = 'mf_ext' 3957 params = ['local_tm', 'CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3958 elif model == 'tm19': 3959 equation = 'mf_orig' 3960 params = ['local_tm', 'CSA', 'Rex'] 3961 3962 # Block 3. 3963 elif model == 'tm20': 3964 equation = 'mf_orig' 3965 params = ['local_tm', 'r'] 3966 elif model == 'tm21': 3967 equation = 'mf_orig' 3968 params = ['local_tm', 'r', 'S2'] 3969 elif model == 'tm22': 3970 equation = 'mf_orig' 3971 params = ['local_tm', 'r', 'S2', 'te'] 3972 elif model == 'tm23': 3973 equation = 'mf_orig' 3974 params = ['local_tm', 'r', 'S2', 'Rex'] 3975 elif model == 'tm24': 3976 equation = 'mf_orig' 3977 params = ['local_tm', 'r', 'S2', 'te', 'Rex'] 3978 elif model == 'tm25': 3979 equation = 'mf_ext' 3980 params = ['local_tm', 'r', 'S2f', 'S2', 'ts'] 3981 elif model == 'tm26': 3982 equation = 'mf_ext' 3983 params = ['local_tm', 'r', 'S2f', 'tf', 'S2', 'ts'] 3984 elif model == 'tm27': 3985 equation = 'mf_ext' 3986 params = ['local_tm', 'r', 'S2f', 'S2', 'ts', 'Rex'] 3987 elif model == 'tm28': 3988 equation = 'mf_ext' 3989 params = ['local_tm', 'r', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 3990 elif model == 'tm29': 3991 equation = 'mf_orig' 3992 params = ['local_tm', 'r', 'Rex'] 3993 3994 # Block 4. 3995 elif model == 'tm30': 3996 equation = 'mf_orig' 3997 params = ['local_tm', 'r', 'CSA'] 3998 elif model == 'tm31': 3999 equation = 'mf_orig' 4000 params = ['local_tm', 'r', 'CSA', 'S2'] 4001 elif model == 'tm32': 4002 equation = 'mf_orig' 4003 params = ['local_tm', 'r', 'CSA', 'S2', 'te'] 4004 elif model == 'tm33': 4005 equation = 'mf_orig' 4006 params = ['local_tm', 'r', 'CSA', 'S2', 'Rex'] 4007 elif model == 'tm34': 4008 equation = 'mf_orig' 4009 params = ['local_tm', 'r', 'CSA', 'S2', 'te', 'Rex'] 4010 elif model == 'tm35': 4011 equation = 'mf_ext' 4012 params = ['local_tm', 'r', 'CSA', 'S2f', 'S2', 'ts'] 4013 elif model == 'tm36': 4014 equation = 'mf_ext' 4015 params = ['local_tm', 'r', 'CSA', 'S2f', 'tf', 'S2', 'ts'] 4016 elif model == 'tm37': 4017 equation = 'mf_ext' 4018 params = ['local_tm', 'r', 'CSA', 'S2f', 'S2', 'ts', 'Rex'] 4019 elif model == 'tm38': 4020 equation = 'mf_ext' 4021 params = ['local_tm', 'r', 'CSA', 'S2f', 'tf', 'S2', 'ts', 'Rex'] 4022 elif model == 'tm39': 4023 equation = 'mf_orig' 4024 params = ['local_tm', 'r', 'CSA', 'Rex'] 4025 4026 # Invalid model. 4027 else: 4028 raise RelaxError, "The model '" + model + "' is invalid." 4029 4030 # Set up the model. 4031 self.model_setup(self.run, model, equation, params, res_num)

4032 4033

4034 - def set_doc(self):

4035 """ 4036 Model-free set details 4037 ~~~~~~~~~~~~~~~~~~~~~~ 4038 4039 Setting a parameter value may have no effect depending on which model-free model is chosen, 4040 for example if S2f values and S2s values are set but the run corresponds to model-free model 4041 'm4' then, because these data values are not parameters of the model, they will have no 4042 effect. 4043 4044 Note that the Rex values are scaled quadratically with field strength and should be supplied 4045 as a field strength independent value. Use the following formula to get the correct value: 4046 4047 value = Rex / (2.0 * pi * frequency) ** 2 4048 4049 where: 4050 Rex is the chemical exchange value for the current frequency. 4051 pi is in the namespace of relax, ie just type 'pi'. 4052 frequency is the proton frequency corresponding to the data. 4053 """

4054 4055

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

4057 """Function for setting parameter errors.""" 4058 4059 # Arguments. 4060 self.run = run 4061 4062 # Parameter increment counter. 4063 inc = 0 4064 4065 # Get the parameter object names. 4066 param_names = self.data_names(set='params') 4067 4068 4069 # Diffusion tensor parameter errors. 4070 #################################### 4071 4072 if self.param_set == 'diff' or self.param_set == 'all': 4073 # Spherical diffusion. 4074 if self.relax.data.diff[self.run].type == 'sphere': 4075 # Return the parameter array. 4076 if index == 0: 4077 self.relax.data.diff[self.run].tm_err = error 4078 4079 # Increment. 4080 inc = inc + 1 4081 4082 # Spheroidal diffusion. 4083 elif self.relax.data.diff[self.run].type == 'spheroid': 4084 # Return the parameter array. 4085 if index == 0: 4086 self.relax.data.diff[self.run].tm_err = error 4087 elif index == 1: 4088 self.relax.data.diff[self.run].Da_err = error 4089 elif index == 2: 4090 self.relax.data.diff[self.run].theta_err = error 4091 elif index == 3: 4092 self.relax.data.diff[self.run].phi_err = error 4093 4094 # Increment. 4095 inc = inc + 4 4096 4097 # Ellipsoidal diffusion. 4098 elif self.relax.data.diff[self.run].type == 'ellipsoid': 4099 # Return the parameter array. 4100 if index == 0: 4101 self.relax.data.diff[self.run].tm_err = error 4102 elif index == 1: 4103 self.relax.data.diff[self.run].Da_err = error 4104 elif index == 2: 4105 self.relax.data.diff[self.run].Dr_err = error 4106 elif index == 3: 4107 self.relax.data.diff[self.run].alpha_err = error 4108 elif index == 4: 4109 self.relax.data.diff[self.run].beta_err = error 4110 elif index == 5: 4111 self.relax.data.diff[self.run].gamma_err = error 4112 4113 # Increment. 4114 inc = inc + 6 4115 4116 4117 # Model-free parameter errors for the parameter set 'all'. 4118 ########################################################## 4119 4120 if self.param_set == 'all': 4121 # Loop over the sequence. 4122 for i in xrange(len(self.relax.data.res[self.run])): 4123 # Skip unselected residues. 4124 if not self.relax.data.res[self.run][i].select: 4125 continue 4126 4127 # Loop over the residue specific parameters. 4128 for param in param_names: 4129 # Return the parameter array. 4130 if index == inc: 4131 setattr(self.relax.data.res[self.run][i], param + "_err", error) 4132 4133 # Increment. 4134 inc = inc + 1 4135 4136 4137 # Model-free parameters for the parameter sets 'mf' and 'local_tm'. 4138 ################################################################### 4139 4140 if self.param_set == 'mf' or self.param_set == 'local_tm': 4141 # Skip unselected residues. 4142 if not self.relax.data.res[self.run][instance].select: 4143 return 4144 4145 # Loop over the residue specific parameters. 4146 for param in param_names: 4147 # Return the parameter array. 4148 if index == inc: 4149 setattr(self.relax.data.res[self.run][instance], param + "_err", error) 4150 4151 # Increment. 4152 inc = inc + 1

4153 4154

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

4156 """Function for returning the array of selected simulation flags.""" 4157 4158 # Arguments. 4159 self.run = run 4160 4161 # Determine the parameter set type. 4162 self.param_set = self.determine_param_set_type() 4163 4164 # Single instance. 4165 if self.param_set == 'all' or self.param_set == 'diff': 4166 if not hasattr(self.relax.data, 'select_sim'): 4167 self.relax.data.select_sim = {} 4168 self.relax.data.select_sim[self.run] = select_sim 4169 4170 # Multiple instances. 4171 else: 4172 self.relax.data.res[self.run][instance].select_sim = select_sim

4173 4174

4175 - def set_update(self, run, param, index):

4176 """Function to update the other model-free parameters.""" 4177 4178 # Alias the residue specific data structure. 4179 data = self.relax.data.res[self.run][index] 4180 4181 # S2f parameter. 4182 if param == 'S2f': 4183 # Update S2 if S2s exists. 4184 if hasattr(data, 's2s') and data.s2s != None: 4185 data.s2 = data.s2f * data.s2s 4186 4187 4188 # S2s parameter. 4189 if param == 'S2s': 4190 # Update S2 if S2f exists. 4191 if hasattr(data, 's2f') and data.s2f != None: 4192 data.s2 = data.s2f * data.s2s

4193 4194

4195 - def sim_init_values(self, run):

4196 """Function for initialising Monte Carlo parameter values.""" 4197 4198 # Arguments. 4199 self.run = run 4200 4201 # Determine the parameter set type. 4202 self.param_set = self.determine_param_set_type() 4203 4204 # Get the parameter object names. 4205 param_names = self.data_names(set='params') 4206 4207 # Get the minimisation statistic object names. 4208 min_names = self.data_names(set='min') 4209 4210 # List of diffusion tensor parameters. 4211 if self.param_set == 'diff' or self.param_set == 'all': 4212 # Spherical diffusion. 4213 if self.relax.data.diff[self.run].type == 'sphere': 4214 diff_params = ['tm'] 4215 4216 # Spheroidal diffusion. 4217 elif self.relax.data.diff[self.run].type == 'spheroid': 4218 diff_params = ['tm', 'Da', 'theta', 'phi'] 4219 4220 # Ellipsoidal diffusion. 4221 elif self.relax.data.diff[self.run].type == 'ellipsoid': 4222 diff_params = ['tm', 'Da', 'Dr', 'alpha', 'beta', 'gamma'] 4223 4224 4225 # Test if Monte Carlo parameter values have already been set. 4226 ############################################################# 4227 4228 # Diffusion tensor parameters and non residue specific minimisation statistics. 4229 if self.param_set == 'diff' or self.param_set == 'all': 4230 # Loop over the parameters. 4231 for object_name in diff_params: 4232 # Name for the simulation object. 4233 sim_object_name = object_name + '_sim' 4234 4235 # Test if the simulation object already exists. 4236 if hasattr(self.relax.data.diff[self.run], sim_object_name): 4237 raise RelaxError, "Monte Carlo parameter values have already been set." 4238 4239 # Loop over the minimisation stats objects. 4240 for object_name in min_names: 4241 # Name for the simulation object. 4242 sim_object_name = object_name + '_sim' 4243 4244 # Test if the simulation object already exists. 4245 if hasattr(self.relax.data, sim_object_name): 4246 raise RelaxError, "Monte Carlo parameter values have already been set." 4247 4248 # Residue specific parameters. 4249 if self.param_set != 'diff': 4250 for i in xrange(len(self.relax.data.res[self.run])): 4251 # Skip unselected residues. 4252 if not self.relax.data.res[self.run][i].select: 4253 continue 4254 4255 # Loop over all the parameter names. 4256 for object_name in param_names: 4257 # Name for the simulation object. 4258 sim_object_name = object_name + '_sim' 4259 4260 # Test if the simulation object already exists. 4261 if hasattr(self.relax.data.res[self.run][i], sim_object_name): 4262 raise RelaxError, "Monte Carlo parameter values have already been set." 4263 4264 4265 # Set the Monte Carlo parameter values. 4266 ####################################### 4267 4268 # Loop over the global minimisation stats objects. 4269 for object_name in min_names: 4270 # Name for the simulation object. 4271 sim_object_name = object_name + '_sim' 4272 4273 # Create the simulation object. 4274 setattr(self.relax.data, sim_object_name, {}) 4275 4276 # Get the simulation object. 4277 sim_object = getattr(self.relax.data, sim_object_name) 4278 4279 # Add the run. 4280 sim_object[self.run] = [] 4281 4282 # Loop over the simulations. 4283 for j in xrange(self.relax.data.sim_number[self.run]): 4284 # Get the object. 4285 object = getattr(self.relax.data, object_name) 4286 4287 # Test if the object has the key self.run. 4288 if not object.has_key(self.run): 4289 continue 4290 4291 # Copy and append the data. 4292 sim_object[self.run].append(deepcopy(object[self.run])) 4293 4294 # Diffusion tensor parameters and non residue specific minimisation statistics. 4295 if self.param_set == 'diff' or self.param_set == 'all': 4296 # Loop over the parameters. 4297 for object_name in diff_params: 4298 # Name for the simulation object. 4299 sim_object_name = object_name + '_sim' 4300 4301 # Create the simulation object. 4302 setattr(self.relax.data.diff[self.run], sim_object_name, []) 4303 4304 # Get the simulation object. 4305 sim_object = getattr(self.relax.data.diff[self.run], sim_object_name) 4306 4307 # Loop over the simulations. 4308 for j in xrange(self.relax.data.sim_number[self.run]): 4309 # Copy and append the data. 4310 sim_object.append(deepcopy(getattr(self.relax.data.diff[self.run], object_name))) 4311 4312 # Residue specific parameters. 4313 if self.param_set != 'diff': 4314 for i in xrange(len(self.relax.data.res[self.run])): 4315 # Skip unselected residues. 4316 if not self.relax.data.res[self.run][i].select: 4317 continue 4318 4319 # Loop over all the data names. 4320 for object_name in param_names: 4321 # Name for the simulation object. 4322 sim_object_name = object_name + '_sim' 4323 4324 # Create the simulation object. 4325 setattr(self.relax.data.res[self.run][i], sim_object_name, []) 4326 4327 # Get the simulation object. 4328 sim_object = getattr(self.relax.data.res[self.run][i], sim_object_name) 4329 4330 # Loop over the simulations. 4331 for j in xrange(self.relax.data.sim_number[self.run]): 4332 # Copy and append the data. 4333 sim_object.append(deepcopy(getattr(self.relax.data.res[self.run][i], object_name))) 4334 4335 # Loop over all the minimisation object names. 4336 for object_name in min_names: 4337 # Name for the simulation object. 4338 sim_object_name = object_name + '_sim' 4339 4340 # Create the simulation object. 4341 setattr(self.relax.data.res[self.run][i], sim_object_name, []) 4342 4343 # Get the simulation object. 4344 sim_object = getattr(self.relax.data.res[self.run][i], sim_object_name) 4345 4346 # Loop over the simulations. 4347 for j in xrange(self.relax.data.sim_number[self.run]): 4348 # Copy and append the data. 4349 sim_object.append(deepcopy(getattr(self.relax.data.res[self.run][i], object_name)))

4350 4351

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

4353 """Function for packing Monte Carlo simulation data.""" 4354 4355 # Test if the simulation data already exists. 4356 if hasattr(self.relax.data.res[run][i], 'relax_sim_data'): 4357 raise RelaxError, "Monte Carlo simulation data already exists." 4358 4359 # Create the data structure. 4360 self.relax.data.res[run][i].relax_sim_data = sim_data

4361 4362

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

4364 """Function for returning the array of simulation chi-squared values.""" 4365 4366 # Arguments. 4367 self.run = run 4368 4369 # Determine the parameter set type. 4370 self.param_set = self.determine_param_set_type() 4371 4372 # Single instance. 4373 if self.param_set == 'all' or self.param_set == 'diff': 4374 return self.relax.data.chi2_sim[self.run] 4375 4376 # Multiple instances. 4377 else: 4378 return self.relax.data.res[self.run][instance].chi2_sim

4379 4380

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

4382 """Function for returning the array of simulation parameter values.""" 4383 4384 # Arguments. 4385 self.run = run 4386 4387 # Parameter increment counter. 4388 inc = 0 4389 4390 # Get the parameter object names. 4391 param_names = self.data_names(set='params') 4392 4393 4394 # Diffusion tensor parameters. 4395 ############################## 4396 4397 if self.param_set == 'diff' or self.param_set == 'all': 4398 # Spherical diffusion. 4399 if self.relax.data.diff[self.run].type == 'sphere': 4400 # Return the parameter array. 4401 if index == 0: 4402 return self.relax.data.diff[self.run].tm_sim 4403 4404 # Increment. 4405 inc = inc + 1 4406 4407 # Spheroidal diffusion. 4408 elif self.relax.data.diff[self.run].type == 'spheroid': 4409 # Return the parameter array. 4410 if index == 0: 4411 return self.relax.data.diff[self.run].tm_sim 4412 elif index == 1: 4413 return self.relax.data.diff[self.run].Da_sim 4414 elif index == 2: 4415 return self.relax.data.diff[self.run].theta_sim 4416 elif index == 3: 4417 return self.relax.data.diff[self.run].phi_sim 4418 4419 # Increment. 4420 inc = inc + 4 4421 4422 # Ellipsoidal diffusion. 4423 elif self.relax.data.diff[self.run].type == 'ellipsoid': 4424 # Return the parameter array. 4425 if index == 0: 4426 return self.relax.data.diff[self.run].tm_sim 4427 elif index == 1: 4428 return self.relax.data.diff[self.run].Da_sim 4429 elif index == 2: 4430 return self.relax.data.diff[self.run].Dr_sim 4431 elif index == 3: 4432 return self.relax.data.diff[self.run].alpha_sim 4433 elif index == 4: 4434 return self.relax.data.diff[self.run].beta_sim 4435 elif index == 5: 4436 return self.relax.data.diff[self.run].gamma_sim 4437 4438 # Increment. 4439 inc = inc + 6 4440 4441 4442 # Model-free parameters for the parameter set 'all'. 4443 #################################################### 4444 4445 if self.param_set == 'all': 4446 # Loop over the sequence. 4447 for i in xrange(len(self.relax.data.res[self.run])): 4448 # Skip unselected residues. 4449 if not self.relax.data.res[self.run][i].select: 4450 continue 4451 4452 # Loop over the residue specific parameters. 4453 for param in param_names: 4454 # Return the parameter array. 4455 if index == inc: 4456 return getattr(self.relax.data.res[self.run][i], param + "_sim") 4457 4458 # Increment. 4459 inc = inc + 1 4460 4461 4462 # Model-free parameters for the parameter sets 'mf' and 'local_tm'. 4463 ################################################################### 4464 4465 if self.param_set == 'mf' or self.param_set == 'local_tm': 4466 # Skip unselected residues. 4467 if not self.relax.data.res[self.run][instance].select: 4468 return 4469 4470 # Loop over the residue specific parameters. 4471 for param in param_names: 4472 # Return the parameter array. 4473 if index == inc: 4474 return getattr(self.relax.data.res[self.run][instance], param + "_sim") 4475 4476 # Increment. 4477 inc = inc + 1

4478 4479

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

4481 """Function for returning the array of selected simulation flags.""" 4482 4483 # Arguments. 4484 self.run = run 4485 4486 # Determine the parameter set type. 4487 self.param_set = self.determine_param_set_type() 4488 4489 # Single instance. 4490 if self.param_set == 'all' or self.param_set == 'diff': 4491 return self.relax.data.select_sim[self.run] 4492 4493 # Multiple instances. 4494 else: 4495 return self.relax.data.res[self.run][instance].select_sim

4496 4497

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

4499 """Function for skiping certain data.""" 4500 4501 # Arguments. 4502 self.run = run 4503 4504 # Determine the parameter set type. 4505 self.param_set = self.determine_param_set_type() 4506 4507 # All residues. 4508 combine = 0 4509 if min_instances == 1 and min_instances != num_instances: 4510 combine = 1 4511 4512 # Sequence specific data. 4513 if (self.param_set == 'mf' or self.param_set == 'local_tm') and not combine and not self.relax.data.res[self.run][instance].select: 4514 return 1 4515 4516 # Don't skip. 4517 return 0

4518 4519

4520 - def unselect(self, run, i, sim_index=None):

4521 """Function for unselecting models or simulations.""" 4522 4523 # Arguments. 4524 self.run = run 4525 4526 # Determine the parameter set type. 4527 self.param_set = self.determine_param_set_type() 4528 4529 # Simulation unselect. 4530 if sim_index != None: 4531 # Single instance. 4532 if self.param_set == 'mf' or self.param_set == 'local_tm': 4533 self.relax.data.res[self.run][i].select_sim[sim_index] = 0 4534 4535 # Multiple instances. 4536 else: 4537 self.relax.data.select_sim[self.run][sim_index] = 0 4538 4539 # Residue unselect. 4540 else: 4541 # Single residue. 4542 if self.param_set == 'mf' or self.param_set == 'local_tm': 4543 self.relax.data.res[self.run][i].select = 0

4544 4545

4546 - def write_columnar_line(self, file=None, num=None, name=None, select=None, select_sim=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):

4547 """Function for printing a single line of the columnar formatted results.""" 4548 4549 # Residue number and name. 4550 file.write("%-4s %-5s " % (num, name)) 4551 4552 # Selected flag. 4553 if select_sim != None: 4554 file.write("%-9s " % select_sim) 4555 else: 4556 file.write("%-9s " % select) 4557 4558 # Data set. 4559 file.write("%-9s " % data_set) 4560 4561 # Nucleus. 4562 file.write("%-7s " % nucleus) 4563 4564 # Model details. 4565 file.write("%-5s %-9s %-35s " % (model, equation, params)) 4566 4567 # Parameter set. 4568 file.write("%-10s " % param_set) 4569 4570 # Parameters. 4571 file.write("%-25s " % s2) 4572 file.write("%-25s " % s2f) 4573 file.write("%-25s " % s2s) 4574 file.write("%-25s " % local_tm) 4575 file.write("%-25s " % te) 4576 file.write("%-25s " % tf) 4577 file.write("%-25s " % ts) 4578 file.write("%-25s " % rex) 4579 file.write("%-25s " % r) 4580 file.write("%-25s " % csa) 4581 4582 # Minimisation results. 4583 file.write("%-25s %-8s %-8s %-8s %-8s %-45s " % (chi2, i, f, g, h, warn)) 4584 4585 # Diffusion parameters. 4586 file.write("%-10s " % diff_type) 4587 if diff_params: 4588 for i in xrange(len(diff_params)): 4589 file.write("%-25s " % diff_params[i]) 4590 4591 # PDB. 4592 file.write("%-40s " % pdb) 4593 file.write("%-10s " % pdb_model) 4594 file.write("%-15s " % pdb_heteronuc) 4595 file.write("%-15s " % pdb_proton) 4596 4597 # XH unit vector. 4598 file.write("%-70s " % xh_vect) 4599 4600 # Relaxation data setup. 4601 if ri_labels: 4602 file.write("%-40s " % ri_labels) 4603 file.write("%-25s " % remap_table) 4604 file.write("%-25s " % frq_labels) 4605 file.write("%-30s " % frq) 4606 4607 # Relaxation data. 4608 if ri: 4609 for i in xrange(len(ri)): 4610 if ri[i] == None: 4611 file.write("%-25s " % 'None') 4612 else: 4613 file.write("%-25s " % ri[i]) 4614 4615 # Relaxation errors. 4616 if ri_error: 4617 for i in xrange(len(ri_error)): 4618 if ri_error[i] == None: 4619 file.write("%-25s " % 'None') 4620 else: 4621 file.write("%-25s " % ri_error[i]) 4622 4623 # End of the line. 4624 file.write("\n")

4625 4626

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

4628 """Function for printing the results into a file.""" 4629 4630 # Arguments. 4631 self.run = run 4632 4633 # Determine the parameter set type. 4634 self.param_set = self.determine_param_set_type() 4635 4636 4637 # Header. 4638 ######### 4639 4640 # Diffusion parameters. 4641 diff_params = None 4642 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run): 4643 # Sphere. 4644 if self.relax.data.diff[self.run].type == 'sphere': 4645 diff_params = ['tm_(s)'] 4646 4647 # Spheroid. 4648 elif self.relax.data.diff[self.run].type == 'spheroid': 4649 diff_params = ['tm_(s)', 'Da_(1/s)', 'theta_(deg)', 'phi_(deg)'] 4650 4651 # Ellipsoid. 4652 elif self.relax.data.diff[self.run].type == 'ellipsoid': 4653 diff_params = ['tm_(s)', 'Da_(1/s)', 'Dr_(1/s)', 'alpha_(deg)', 'beta_(deg)', 'gamma_(deg)'] 4654 4655 # Relaxation data and errors. 4656 ri = [] 4657 ri_error = [] 4658 if hasattr(self.relax.data, 'num_ri'): 4659 for i in xrange(self.relax.data.num_ri[self.run]): 4660 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]] + ")") 4661 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]] + ")") 4662 4663 # Write the header line. 4664 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_(' + self.return_units('local_tm') + ')', te='te_(' + self.return_units('te') + ')', tf='tf_(' + self.return_units('tf') + ')', ts='ts_(' + self.return_units('ts') + ')', rex='Rex_(' + replace(self.return_units('rex'), ' ', '_') + ')', r='Bond_length_(' + self.return_units('r') + ')', csa='CSA_(' + self.return_units('csa') + ')', 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) 4665 4666 4667 # Values. 4668 ######### 4669 4670 # Nucleus. 4671 nucleus = self.relax.generic.nuclei.find_nucleus() 4672 4673 # Diffusion parameters. 4674 diff_type = None 4675 diff_params = None 4676 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run): 4677 # Sphere. 4678 if self.relax.data.diff[self.run].type == 'sphere': 4679 diff_type = 'sphere' 4680 diff_params = [`self.relax.data.diff[self.run].tm`] 4681 4682 # Spheroid. 4683 elif self.relax.data.diff[self.run].type == 'spheroid': 4684 diff_type = self.relax.data.diff[self.run].spheroid_type 4685 if diff_type == None: 4686 diff_type = 'spheroid' 4687 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)`] 4688 4689 # Ellipsoid. 4690 elif self.relax.data.diff[self.run].type == 'ellipsoid': 4691 diff_type = 'ellipsoid' 4692 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)`] 4693 4694 # PDB. 4695 pdb = None 4696 pdb_model = None 4697 pdb_heteronuc = None 4698 pdb_proton = None 4699 if self.relax.data.pdb.has_key(self.run): 4700 pdb = self.relax.data.pdb[self.run].file_name 4701 pdb_model = self.relax.data.pdb[self.run].model 4702 pdb_heteronuc = self.relax.data.pdb[self.run].heteronuc 4703 pdb_proton = self.relax.data.pdb[self.run].proton 4704 4705 # Relaxation data setup. 4706 try: 4707 ri_labels = replace(`self.relax.data.ri_labels[self.run]`, ' ', '') 4708 remap_table = replace(`self.relax.data.remap_table[self.run]`, ' ', '') 4709 frq_labels = replace(`self.relax.data.frq_labels[self.run]`, ' ', '') 4710 frq = replace(`self.relax.data.frq[self.run]`, ' ', '') 4711 except AttributeError: 4712 ri_labels = `None` 4713 remap_table = `None` 4714 frq_labels = `None` 4715 frq = `None` 4716 4717 # Loop over the sequence. 4718 for i in xrange(len(self.relax.data.res[self.run])): 4719 # Reassign data structure. 4720 data = self.relax.data.res[self.run][i] 4721 4722 # Model details. 4723 model = None 4724 if hasattr(data, 'model'): 4725 model = data.model 4726 4727 equation = None 4728 if hasattr(data, 'equation'): 4729 equation = data.equation 4730 4731 params = None 4732 if hasattr(data, 'params'): 4733 params = replace(`data.params`, ' ', '') 4734 4735 # S2. 4736 s2 = None 4737 if hasattr(data, 's2') and data.s2 != None: 4738 s2 = data.s2 / self.return_conversion_factor('s2') 4739 s2 = `s2` 4740 4741 # S2f. 4742 s2f = None 4743 if hasattr(data, 's2f') and data.s2f != None: 4744 s2f = data.s2f / self.return_conversion_factor('s2f') 4745 s2f = `s2f` 4746 4747 # S2s. 4748 s2s = None 4749 if hasattr(data, 's2s') and data.s2s != None: 4750 s2s = data.s2s / self.return_conversion_factor('s2s') 4751 s2s = `s2s` 4752 4753 # Local tm. 4754 local_tm = None 4755 if hasattr(data, 'local_tm') and data.local_tm != None: 4756 local_tm = data.local_tm / self.return_conversion_factor('local_tm') 4757 local_tm = `local_tm` 4758 4759 # te. 4760 te = None 4761 if hasattr(data, 'te') and data.te != None: 4762 te = data.te / self.return_conversion_factor('te') 4763 te = `te` 4764 4765 # tf. 4766 tf = None 4767 if hasattr(data, 'tf') and data.tf != None: 4768 tf = data.tf / self.return_conversion_factor('tf') 4769 tf = `tf` 4770 4771 # ts. 4772 ts = None 4773 if hasattr(data, 'ts') and data.ts != None: 4774 ts = data.ts / self.return_conversion_factor('ts') 4775 ts = `ts` 4776 4777 # Rex. 4778 rex = None 4779 if hasattr(data, 'rex') and data.rex != None: 4780 rex = data.rex / self.return_conversion_factor('rex') 4781 rex = `rex` 4782 4783 # Bond length. 4784 r = None 4785 if hasattr(data, 'r') and data.r != None: 4786 r = data.r / self.return_conversion_factor('r') 4787 r = `r` 4788 4789 # CSA. 4790 csa = None 4791 if hasattr(data, 'csa') and data.csa != None: 4792 csa = data.csa / self.return_conversion_factor('csa') 4793 csa = `csa` 4794 4795 # Minimisation details. 4796 try: 4797 # Global minimisation results. 4798 if self.param_set == 'diff' or self.param_set == 'all': 4799 chi2 = `self.relax.data.chi2[self.run]` 4800 iter = self.relax.data.iter[self.run] 4801 f = self.relax.data.f_count[self.run] 4802 g = self.relax.data.g_count[self.run] 4803 h = self.relax.data.h_count[self.run] 4804 if type(self.relax.data.warning[self.run]) == str: 4805 warn = replace(self.relax.data.warning[self.run], ' ', '_') 4806 else: 4807 warn = self.relax.data.warning[self.run] 4808 4809 # Individual residue results. 4810 else: 4811 chi2 = `data.chi2` 4812 iter = data.iter 4813 f = data.f_count 4814 g = data.g_count 4815 h = data.h_count 4816 if type(data.warning) == str: 4817 warn = replace(data.warning, ' ', '_') 4818 else: 4819 warn = data.warning 4820 4821 # No minimisation details. 4822 except: 4823 chi2 = None 4824 iter = None 4825 f = None 4826 g = None 4827 h = None 4828 warn = None 4829 4830 # XH vector. 4831 xh_vect = None 4832 if hasattr(data, 'xh_vect'): 4833 xh_vect = replace(`data.xh_vect.tolist()`, ' ', '') 4834 4835 # Relaxation data and errors. 4836 ri = [] 4837 ri_error = [] 4838 if hasattr(self.relax.data, 'num_ri'): 4839 for i in xrange(self.relax.data.num_ri[self.run]): 4840 try: 4841 # Find the residue specific data corresponding to i. 4842 index = None 4843 for j in xrange(data.num_ri): 4844 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]]: 4845 index = j 4846 4847 # Data exists for this data type. 4848 ri.append(`data.relax_data[index]`) 4849 ri_error.append(`data.relax_error[index]`) 4850 4851 # No data exists for this data type. 4852 except: 4853 ri.append(None) 4854 ri_error.append(None) 4855 4856 # Write the line. 4857 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) 4858 4859 4860 # Errors. 4861 ######### 4862 4863 # Only invoke this section if errors exist. 4864 if self.has_errors(): 4865 # Diffusion parameters. 4866 diff_params = None 4867 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run): 4868 # Sphere. 4869 if self.relax.data.diff[self.run].type == 'sphere': 4870 diff_params = [None] 4871 4872 # Spheroid. 4873 elif self.relax.data.diff[self.run].type == 'spheroid': 4874 diff_params = [None, None, None, None] 4875 4876 # Ellipsoid. 4877 elif self.relax.data.diff[self.run].type == 'ellipsoid': 4878 diff_params = [None, None, None, None, None, None] 4879 4880 # Diffusion parameter errors. 4881 if self.param_set == 'diff' or self.param_set == 'all': 4882 # Sphere. 4883 if self.relax.data.diff[self.run].type == 'sphere' and hasattr(self.relax.data.diff[self.run], 'tm_err'): 4884 diff_params = [`self.relax.data.diff[self.run].tm_err`] 4885 4886 # Spheroid. 4887 elif self.relax.data.diff[self.run].type == 'spheroid' and hasattr(self.relax.data.diff[self.run], 'tm_err'): 4888 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)`] 4889 4890 # Ellipsoid. 4891 elif self.relax.data.diff[self.run].type == 'ellipsoid' and hasattr(self.relax.data.diff[self.run], 'tm_err'): 4892 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)`] 4893 4894 # Loop over the sequence. 4895 for i in xrange(len(self.relax.data.res[self.run])): 4896 # Reassign data structure. 4897 data = self.relax.data.res[self.run][i] 4898 4899 # Model details. 4900 model = None 4901 if hasattr(data, 'model'): 4902 model = data.model 4903 4904 equation = None 4905 if hasattr(data, 'equation'): 4906 equation = data.equation 4907 4908 params = None 4909 if hasattr(data, 'params'): 4910 params = replace(`data.params`, ' ', '') 4911 4912 # S2. 4913 s2 = None 4914 if hasattr(data, 's2_err') and data.s2_err != None: 4915 s2 = data.s2_err / self.return_conversion_factor('s2') 4916 s2 = `s2` 4917 4918 # S2f. 4919 s2f = None 4920 if hasattr(data, 's2f_err') and data.s2f_err != None: 4921 s2f = data.s2f_err / self.return_conversion_factor('s2f') 4922 s2f = `s2f` 4923 4924 # S2s. 4925 s2s = None 4926 if hasattr(data, 's2s_err') and data.s2s_err != None: 4927 s2s = data.s2s_err / self.return_conversion_factor('s2s') 4928 s2s = `s2s` 4929 4930 # Local tm. 4931 local_tm = None 4932 if hasattr(data, 'local_tm_err') and data.local_tm_err != None: 4933 local_tm = data.local_tm_err / self.return_conversion_factor('local_tm') 4934 local_tm = `local_tm` 4935 4936 # te. 4937 te = None 4938 if hasattr(data, 'te_err') and data.te_err != None: 4939 te = data.te_err / self.return_conversion_factor('te') 4940 te = `te` 4941 4942 # tf. 4943 tf = None 4944 if hasattr(data, 'tf_err') and data.tf_err != None: 4945 tf = data.tf_err / self.return_conversion_factor('tf') 4946 tf = `tf` 4947 4948 # ts. 4949 ts = None 4950 if hasattr(data, 'ts_err') and data.ts_err != None: 4951 ts = data.ts_err / self.return_conversion_factor('ts') 4952 ts = `ts` 4953 4954 # Rex. 4955 rex = None 4956 if hasattr(data, 'rex_err') and data.rex_err != None: 4957 rex = data.rex_err / self.return_conversion_factor('rex') 4958 rex = `rex` 4959 4960 # Bond length. 4961 r = None 4962 if hasattr(data, 'r_err') and data.r_err != None: 4963 r = data.r_err / self.return_conversion_factor('r') 4964 r = `r` 4965 4966 # CSA. 4967 csa = None 4968 if hasattr(data, 'csa_err') and data.csa_err != None: 4969 csa = data.csa_err / self.return_conversion_factor('csa') 4970 csa = `csa` 4971 4972 # Relaxation data and errors. 4973 ri = [] 4974 ri_error = [] 4975 for i in xrange(self.relax.data.num_ri[self.run]): 4976 ri.append(None) 4977 ri_error.append(None) 4978 4979 # XH vector. 4980 xh_vect = None 4981 if hasattr(data, 'xh_vect'): 4982 xh_vect = replace(`data.xh_vect.tolist()`, ' ', '') 4983 4984 # Write the line. 4985 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) 4986 4987 4988 # Simulation values. 4989 #################### 4990 4991 # Only invoke this section if simulations have been setup. 4992 if hasattr(self.relax.data, 'sim_state') and self.relax.data.sim_state[self.run]: 4993 # Loop over the simulations. 4994 for i in xrange(self.relax.data.sim_number[self.run]): 4995 # Diffusion parameters. 4996 diff_params = None 4997 if self.param_set != 'local_tm' and hasattr(self.relax.data, 'diff') and self.relax.data.diff.has_key(self.run): 4998 # Diffusion parameter simulation values. 4999 if self.param_set == 'diff' or self.param_set == 'all': 5000 # Sphere. 5001 if self.relax.data.diff[self.run].type == 'sphere': 5002 diff_params = [`self.relax.data.diff[self.run].tm_sim[i]`] 5003 5004 # Spheroid. 5005 elif self.relax.data.diff[self.run].type == 'spheroid': 5006 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)`] 5007 5008 # Ellipsoid. 5009 elif self.relax.data.diff[self.run].type == 'ellipsoid': 5010 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)`] 5011 5012 # No simulation values. 5013 else: 5014 # Sphere. 5015 if self.relax.data.diff[self.run].type == 'sphere': 5016 diff_params = [None] 5017 5018 # Spheroid. 5019 elif self.relax.data.diff[self.run].type == 'spheroid': 5020 diff_params = [None, None, None, None] 5021 5022 # Ellipsoid. 5023 elif self.relax.data.diff[self.run].type == 'ellipsoid': 5024 diff_params = [None, None, None, None, None, None] 5025 5026 # Loop over the sequence. 5027 for j in xrange(len(self.relax.data.res[self.run])): 5028 # Reassign data structure. 5029 data = self.relax.data.res[self.run][j] 5030 5031 # Model details. 5032 model = None 5033 if hasattr(data, 'model'): 5034 model = data.model 5035 5036 equation = None 5037 if hasattr(data, 'equation'): 5038 equation = data.equation 5039 5040 params = None 5041 if hasattr(data, 'params'): 5042 params = replace(`data.params`, ' ', '') 5043 5044 # Selected simulation. 5045 if self.param_set == 'diff' or self.param_set == 'all': 5046 select_sim = self.relax.data.select_sim[self.run][i] 5047 else: 5048 select_sim = data.select_sim[i] 5049 5050 # S2. 5051 s2 = None 5052 if hasattr(data, 's2_sim') and data.s2_sim[i] != None: 5053 s2 = data.s2_sim[i] / self.return_conversion_factor('s2') 5054 s2 = `s2` 5055 5056 # S2f. 5057 s2f = None 5058 if hasattr(data, 's2f_sim') and data.s2f_sim[i] != None: 5059 s2f = data.s2f_sim[i] / self.return_conversion_factor('s2f') 5060 s2f = `s2f` 5061 5062 # S2s. 5063 s2s = None 5064 if hasattr(data, 's2s_sim') and data.s2s_sim[i] != None: 5065 s2s = data.s2s_sim[i] / self.return_conversion_factor('s2s') 5066 s2s = `s2s` 5067 5068 # Local tm. 5069 local_tm = None 5070 if hasattr(data, 'local_tm_sim') and data.local_tm_sim[i] != None: 5071 local_tm = data.local_tm_sim[i] / self.return_conversion_factor('local_tm') 5072 local_tm = `local_tm` 5073 5074 # te. 5075 te = None 5076 if hasattr(data, 'te_sim') and data.te_sim[i] != None: 5077 te = data.te_sim[i] / self.return_conversion_factor('te') 5078 te = `te` 5079 5080 # tf. 5081 tf = None 5082 if hasattr(data, 'tf_sim') and data.tf_sim[i] != None: 5083 tf = data.tf_sim[i] / self.return_conversion_factor('tf') 5084 tf = `tf` 5085 5086 # ts. 5087 ts = None 5088 if hasattr(data, 'ts_sim') and data.ts_sim[i] != None: 5089 ts = data.ts_sim[i] / self.return_conversion_factor('ts') 5090 ts = `ts` 5091 5092 # Rex. 5093 rex = None 5094 if hasattr(data, 'rex_sim') and data.rex_sim[i] != None: 5095 rex = data.rex_sim[i] / self.return_conversion_factor('rex') 5096 rex = `rex` 5097 5098 # Bond length. 5099 r = None 5100 if hasattr(data, 'r_sim') and data.r_sim[i] != None: 5101 r = data.r_sim[i] / self.return_conversion_factor('r') 5102 r = `r` 5103 5104 # CSA. 5105 csa = None 5106 if hasattr(data, 'csa_sim') and data.csa_sim[i] != None: 5107 csa = data.csa_sim[i] / self.return_conversion_factor('csa') 5108 csa = `csa` 5109 5110 # Minimisation details. 5111 try: 5112 # Global minimisation results. 5113 if self.param_set == 'diff' or self.param_set == 'all': 5114 chi2 = `self.relax.data.chi2_sim[self.run][i]` 5115 iter = self.relax.data.iter_sim[self.run][i] 5116 f = self.relax.data.f_count_sim[self.run][i] 5117 g = self.relax.data.g_count_sim[self.run][i] 5118 h = self.relax.data.h_count_sim[self.run][i] 5119 if type(self.relax.data.warning_sim[self.run][i]) == str: 5120 warn = replace(self.relax.data.warning_sim[self.run][i], ' ', '_') 5121 else: 5122 warn = self.relax.data.warning_sim[self.run][i] 5123 5124 # Individual residue results. 5125 else: 5126 chi2 = `data.chi2_sim[i]` 5127 iter = data.iter_sim[i] 5128 f = data.f_count_sim[i] 5129 g = data.g_count_sim[i] 5130 h = data.h_count_sim[i] 5131 if type(data.warning_sim[i]) == str: 5132 warn = replace(data.warning_sim[i], ' ', '_') 5133 else: 5134 warn = data.warning_sim[i] 5135 5136 # No minimisation details. 5137 except AttributeError: 5138 chi2 = None 5139 iter = None 5140 f = None 5141 g = None 5142 h = None 5143 warn = None 5144 5145 # Relaxation data and errors. 5146 ri = [] 5147 ri_error = [] 5148 if hasattr(self.relax.data, 'num_ri'): 5149 for k in xrange(self.relax.data.num_ri[self.run]): 5150 try: 5151 # Find the residue specific data corresponding to k. 5152 index = None 5153 for l in xrange(data.num_ri): 5154 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]]: 5155 index = l 5156 5157 # Data exists for this data type. 5158 ri.append(`data.relax_sim_data[i][index]`) 5159 ri_error.append(`data.relax_error[index]`) 5160 5161 # No data exists for this data type. 5162 except: 5163 ri.append(None) 5164 ri_error.append(None) 5165 5166 # XH vector. 5167 xh_vect = None 5168 if hasattr(data, 'xh_vect'): 5169 xh_vect = replace(`data.xh_vect.tolist()`, ' ', '') 5170 5171 # Write the line. 5172 self.write_columnar_line(file=file, num=data.num, name=data.name, select=data.select, select_sim=select_sim, 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