specific_fns.model

37 - def __init__(self, relax):

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

41 42

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

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

94 95

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

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

138 139

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

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

301 302

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

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

383 384

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

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

396 397

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

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

543 544

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

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

609 610

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

612 """Function for creating the Monte Carlo Ri data.""" 613 614 # Arguments 615 self.run = run 616 617 # Initialise the data data structure. 618 data = [] 619 620 # Test if the model is set. 621 if not hasattr(self.relax.data.res[self.run][i], 'model') or not self.relax.data.res[self.run][i].model: 622 raise RelaxNoMfModelError, self.run 623 624 # Loop over the relaxation data. 625 for j in xrange(len(self.relax.data.res[run][i].relax_data)): 626 # Back calculate the value. 627 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]]) 628 629 # Append the value. 630 data.append(value) 631 632 # Return the data. 633 return data

634 635

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

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

768 769

770 - def data_init(self, data):

771 """Function for initialising the data structures.""" 772 773 # Get the data names. 774 data_names = self.data_names() 775 776 # Loop over the data structure names. 777 for name in data_names: 778 # Data structures which are initially empty arrays. 779 list_data = [ 'params' ] 780 if name in list_data: 781 # If the name is not in 'data', add it. 782 if not hasattr(data, name): 783 setattr(data, name, []) 784 785 # Data structures which are initially None. 786 none_data = [ 'equation', 787 'model', 788 's2', 789 's2f', 790 's2s', 791 'tm', 792 'te', 793 'tf', 794 'ts', 795 'rex', 796 'r', 797 'csa', 798 'chi2', 799 'iter', 800 'f_count', 801 'g_count', 802 'h_count', 803 'warning' ] 804 if name in none_data: 805 # If the name is not in 'data', add it. 806 if not hasattr(data, name): 807 setattr(data, name, None)

808 809

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

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

889 890

891 - def default_value(self, param):

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

951 952

953 - def delete(self, run):

954 """Function for deleting all model-free data.""" 955 956 # Arguments. 957 self.run = run 958 959 # Test if the run exists. 960 if not self.run in self.relax.data.run_names: 961 raise RelaxNoRunError, self.run 962 963 # Test if the run type is set to 'mf'. 964 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 965 if function_type != 'mf': 966 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 967 968 # Test if the sequence data is loaded. 969 if not self.relax.data.res.has_key(self.run): 970 raise RelaxNoSequenceError, self.run 971 972 # Get all data structure names. 973 names = self.data_names() 974 975 # Loop over the sequence. 976 for i in xrange(len(self.relax.data.res[self.run])): 977 # Remap the data structure 'self.relax.data.res[self.run][i]'. 978 data = self.relax.data.res[self.run][i] 979 980 # Loop through the data structure names. 981 for name in names: 982 # Skip the data structure if it does not exist. 983 if not hasattr(data, name): 984 continue 985 986 # Delete the data. 987 delattr(data, name) 988 989 # Clean up the runs. 990 self.relax.generic.runs.eliminate_unused_runs()

991 992

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

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

1062 1063

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

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

1290 1291

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

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

1353 1354

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

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

1417 1418

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

1420 """Function for returning a vector of parameter names.""" 1421 1422 # Arguments 1423 self.run = run 1424 1425 # Skip residues where there is no data or errors. 1426 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not hasattr(self.relax.data.res[self.run][i], 'relax_error'): 1427 return 1428 1429 # Test if the model-free model has been setup. 1430 for j in xrange(len(self.relax.data.res[self.run])): 1431 # Skip unselected residues. 1432 if not self.relax.data.res[self.run][j].select: 1433 continue 1434 1435 # Not setup. 1436 if not self.relax.data.res[self.run][j].model: 1437 raise RelaxNoMfModelError, self.run 1438 1439 # Determine the parameter set type. 1440 self.param_set = self.determine_param_set_type() 1441 1442 # Residue index. 1443 if self.param_set == 'mf' or self.param_set == 'local_tm': 1444 index = i 1445 else: 1446 index = None 1447 1448 # Assemble the parameter names. 1449 self.assemble_param_names(index=index) 1450 1451 # Return the parameter names. 1452 return self.param_names

1453 1454

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

1456 """Function for returning a vector of parameter values.""" 1457 1458 # Arguments 1459 self.run = run 1460 1461 # Skip residues where there is no data or errors. 1462 if not hasattr(self.relax.data.res[self.run][i], 'relax_data') or not hasattr(self.relax.data.res[self.run][i], 'relax_error'): 1463 return 1464 1465 # Test if the model-free model has been setup. 1466 for j in xrange(len(self.relax.data.res[self.run])): 1467 # Skip unselected residues. 1468 if not self.relax.data.res[self.run][j].select: 1469 continue 1470 1471 # Not setup. 1472 if not self.relax.data.res[self.run][j].model: 1473 raise RelaxNoMfModelError, self.run 1474 1475 # Determine the parameter set type. 1476 self.param_set = self.determine_param_set_type() 1477 1478 # Residue index. 1479 if self.param_set == 'mf' or self.param_set == 'local_tm': 1480 index = i 1481 else: 1482 index = None 1483 1484 # Assemble the parameter values. 1485 self.param_vector = self.assemble_param_vector(index=index, sim_index=sim_index) 1486 1487 # Return the parameter names. 1488 return self.param_vector

1489 1490

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

1492 """The grid search function.""" 1493 1494 # Arguments. 1495 self.lower = lower 1496 self.upper = upper 1497 self.inc = inc 1498 1499 # Minimisation. 1500 self.minimise(run=run, min_algor='grid', constraints=constraints, print_flag=print_flag, sim_index=sim_index)

1501 1502

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

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

1635 1636

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

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

1958 1959

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

1961 """The function for creating bounds for the mapping function.""" 1962 1963 # Arguments. 1964 self.run = run 1965 1966 # {S2, S2f, S2s}. 1967 if search('^S2', param): 1968 return [0, 1] 1969 1970 # {tm, te, tf, ts}. 1971 elif search('^t', param): 1972 return [0, 1e-8] 1973 1974 # Rex. 1975 elif param == 'Rex': 1976 return [0, 30.0 / (2.0 * pi * self.relax.data.frq[self.run][0])**2] 1977 1978 # Bond length. 1979 elif param == 'r': 1980 return [1.0 * 1e-10, 1.1 * 1e-10] 1981 1982 # CSA. 1983 elif param == 'CSA': 1984 return [-100 * 1e-6, -300 * 1e-6]

1985 1986

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

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

2450 2451

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

2453 """Function for updating various data structures depending on the model selected.""" 2454 2455 # Test that no diffusion tensor exists for the run if tm is a parameter in the model. 2456 for param in params: 2457 if param == 'tm' and self.relax.data.diff.has_key(run): 2458 raise RelaxTensorError, run 2459 2460 # Loop over the sequence. 2461 for i in xrange(len(self.relax.data.res[run])): 2462 # Skip unselected residues. 2463 if not self.relax.data.res[run][i].select: 2464 continue 2465 2466 # If res_num is set, then skip all other residues. 2467 if res_num != None and res_num != self.relax.data.res[run][i].num: 2468 continue 2469 2470 # Initialise the data structures (if needed). 2471 self.data_init(self.relax.data.res[run][i]) 2472 2473 # Model-free model, equation, and parameter types. 2474 self.relax.data.res[run][i].model = model 2475 self.relax.data.res[run][i].equation = equation 2476 self.relax.data.res[run][i].params = params

2477 2478

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

2480 """Function for returning k, n, and chi2. 2481 2482 k - number of parameters. 2483 n - number of data points. 2484 chi2 - the chi-squared value. 2485 """ 2486 2487 # Arguments. 2488 self.run = run 2489 2490 # All residues. 2491 combine = 0 2492 if min_instances == 1 and min_instances != num_instances: 2493 combine = 1 2494 2495 # Determine if local or global statistics will be returned. 2496 global_stats = 1 2497 for i in xrange(len(self.relax.data.res[self.run])): 2498 if hasattr(self.relax.data.res[self.run][i], 'chi2') and self.relax.data.res[self.run][i].chi2 != None: 2499 global_stats = 0 2500 break 2501 2502 # Statistics for a single residue. 2503 if not global_stats and not combine: 2504 # Missing data sets. 2505 if not hasattr(self.relax.data.res[self.run][instance], 'relax_data'): 2506 return None, None, None 2507 2508 # Count the number of parameters. 2509 self.param_vector = self.assemble_param_vector(index=instance) 2510 k = len(self.param_vector) 2511 2512 # Count the number of data points. 2513 n = len(self.relax.data.res[self.run][instance].relax_data) 2514 2515 # The chi2 value. 2516 chi2 = self.relax.data.res[self.run][instance].chi2 2517 2518 # Statistics for all residues combined. 2519 elif not global_stats and combine: 2520 # Initialise. 2521 k = 0 2522 n = 0 2523 chi2 = 0 2524 2525 # Loop over the sequence. 2526 for i in xrange(len(self.relax.data.res[self.run])): 2527 # Skip unselected residues. 2528 if not self.relax.data.res[self.run][i].select: 2529 continue 2530 2531 # Count the number of parameters. 2532 self.param_vector = self.assemble_param_vector(index=i) 2533 k = k + len(self.param_vector) 2534 2535 # Count the number of data points. 2536 n = n + len(self.relax.data.res[self.run][i].relax_data) 2537 2538 # The chi2 value. 2539 chi2 = chi2 + self.relax.data.res[self.run][i].chi2 2540 2541 # Other data. 2542 elif global_stats: 2543 # Count the number of parameters. 2544 self.param_vector = self.assemble_param_vector() 2545 k = len(self.param_vector) 2546 2547 # Count the number of data points. 2548 n = 0 2549 for i in xrange(len(self.relax.data.res[self.run])): 2550 # Skip unselected residues. 2551 if not self.relax.data.res[self.run][i].select: 2552 continue 2553 2554 n = n + len(self.relax.data.res[self.run][i].relax_data) 2555 2556 # The chi2 value. 2557 chi2 = self.relax.data.chi2[self.run] 2558 2559 # Return the data. 2560 return k, n, chi2

2561 2562

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

2564 """Function for returning the number of instances.""" 2565 2566 # Arguments. 2567 self.run = run 2568 2569 # Test if sequence data is loaded. 2570 if not self.relax.data.res.has_key(self.run): 2571 return 0 2572 2573 # Determine the parameter set type. 2574 self.param_set = self.determine_param_set_type() 2575 2576 # Sequence specific data. 2577 if self.param_set == 'mf' or self.param_set == 'local_tm': 2578 return len(self.relax.data.res[self.run]) 2579 2580 # Other data. 2581 elif self.param_set == 'diff' or self.param_set == 'all': 2582 return 1

2583 2584

2585 - def read_columnar_col_numbers(self, header):

2586 """Function for sorting the column numbers from the columnar formatted results file.""" 2587 2588 # Initialise the hash. 2589 self.col = {} 2590 2591 # Loop over the columns. 2592 for i in xrange(len(header)): 2593 # Residue info. 2594 if header[i] == 'Num': 2595 self.col['num'] = i 2596 elif header[i] == 'Name': 2597 self.col['name'] = i 2598 elif header[i] == 'Selected': 2599 self.col['select'] = i 2600 elif header[i] == 'Data_set': 2601 self.col['data_set'] = i 2602 elif header[i] == 'Nucleus': 2603 self.col['nucleus'] = i 2604 elif header[i] == 'Model': 2605 self.col['model'] = i 2606 elif header[i] == 'Equation': 2607 self.col['eqi'] = i 2608 elif header[i] == 'Params': 2609 self.col['params'] = i 2610 elif header[i] == 'Param_set': 2611 self.col['param_set'] = i 2612 2613 # Parameters. 2614 elif header[i] == 'S2': 2615 self.col['s2'] = i 2616 elif header[i] == 'S2f': 2617 self.col['s2f'] = i 2618 elif header[i] == 'S2s': 2619 self.col['s2s'] = i 2620 elif search('^Local_tm', header[i]): 2621 self.col['local_tm'] = i 2622 elif search('^te', header[i]): 2623 self.col['te'] = i 2624 elif search('^tf', header[i]): 2625 self.col['tf'] = i 2626 elif search('^ts', header[i]): 2627 self.col['ts'] = i 2628 elif search('^Rex', header[i]): 2629 self.col['rex'] = i 2630 elif search('^Bond_length', header[i]): 2631 self.col['r'] = i 2632 elif search('^CSA', header[i]): 2633 self.col['csa'] = i 2634 2635 # Minimisation info. 2636 elif header[i] == 'Chi-squared': 2637 self.col['chi2'] = i 2638 elif header[i] == 'Iter': 2639 self.col['iter'] = i 2640 elif header[i] == 'f_count': 2641 self.col['f_count'] = i 2642 elif header[i] == 'g_count': 2643 self.col['g_count'] = i 2644 elif header[i] == 'h_count': 2645 self.col['h_count'] = i 2646 elif header[i] == 'Warning': 2647 self.col['warn'] = i 2648 2649 # Diffusion tensor. 2650 elif header[i] == 'Diff_type': 2651 self.col['diff_type'] = i 2652 elif header[i] == 'tm_(s)': 2653 self.col['tm'] = i 2654 elif header[i] == 'Da_(1/s)': 2655 self.col['da'] = i 2656 elif header[i] == 'theta_(deg)': 2657 self.col['theta'] = i 2658 elif header[i] == 'phi_(deg)': 2659 self.col['phi'] = i 2660 elif header[i] == 'Da_(1/s)': 2661 self.col['da'] = i 2662 elif header[i] == 'Dr_(1/s)': 2663 self.col['dr'] = i 2664 elif header[i] == 'alpha_(deg)': 2665 self.col['alpha'] = i 2666 elif header[i] == 'beta_(deg)': 2667 self.col['beta'] = i 2668 elif header[i] == 'gamma_(deg)': 2669 self.col['gamma'] = i 2670 2671 # PDB and XH vector. 2672 elif header[i] == 'PDB': 2673 self.col['pdb'] = i 2674 elif header[i] == 'PDB_model': 2675 self.col['pdb_model'] = i 2676 elif header[i] == 'PDB_heteronuc': 2677 self.col['pdb_heteronuc'] = i 2678 elif header[i] == 'PDB_proton': 2679 self.col['pdb_proton'] = i 2680 elif header[i] == 'XH_vector': 2681 self.col['xh_vect'] = i 2682 2683 # Relaxation data. 2684 elif header[i] == 'Ri_labels': 2685 self.col['ri_labels'] = i 2686 elif header[i] == 'Remap_table': 2687 self.col['remap_table'] = i 2688 elif header[i] == 'Frq_labels': 2689 self.col['frq_labels'] = i 2690 elif header[i] == 'Frequencies': 2691 self.col['frq'] = i

2692 2693

2694 - def read_columnar_diff_tensor(self):

2695 """Function for setting up the diffusion tensor from the columnar formatted results file.""" 2696 2697 # The diffusion tensor type. 2698 diff_type = self.file_line[self.col['diff_type']] 2699 if diff_type == 'None': 2700 diff_type = None 2701 2702 # Sphere. 2703 if diff_type == 'sphere': 2704 # Convert the parameters to floating point numbers. 2705 try: 2706 tm = float(self.file_line[self.col['tm']]) 2707 except ValueError: 2708 # Errors or simulation values set to None. 2709 if self.data_set != 'value' and self.file_line[self.col['tm']] == 'None': 2710 return 2711 2712 # Genuine error. 2713 raise RelaxError, "The diffusion tensor parameters are not numbers." 2714 2715 # Values. 2716 if self.data_set == 'value': 2717 diff_params = tm 2718 2719 # Errors. 2720 elif self.data_set == 'error': 2721 self.relax.data.diff[self.run].tm_err = tm 2722 2723 # Simulation values. 2724 else: 2725 # Create the data structure if it doesn't exist. 2726 if not hasattr(self.relax.data.diff[self.run], 'tm_sim'): 2727 self.relax.data.diff[self.run].tm_sim = [] 2728 2729 # Append the value. 2730 self.relax.data.diff[self.run].tm_sim.append(tm) 2731 2732 2733 # Spheroid. 2734 elif diff_type == 'spheroid' or diff_type == 'oblate' or diff_type == 'prolate': 2735 # Convert the parameters to floating point numbers. 2736 try: 2737 tm = float(self.file_line[self.col['tm']]) 2738 Da = float(self.file_line[self.col['da']]) 2739 theta = float(self.file_line[self.col['theta']]) / 360.0 * 2.0 * pi 2740 phi = float(self.file_line[self.col['phi']]) / 360.0 * 2.0 * pi 2741 except ValueError: 2742 # Errors or simulation values set to None. 2743 if self.data_set != 'value' and self.file_line[self.col['tm']] == 'None': 2744 return 2745 2746 # Genuine error. 2747 raise RelaxError, "The diffusion tensor parameters are not numbers." 2748 2749 # Values. 2750 if self.data_set == 'value': 2751 diff_params = [tm, Da, theta, phi] 2752 2753 # Errors. 2754 elif self.data_set == 'error': 2755 self.relax.data.diff[self.run].tm_err = tm 2756 self.relax.data.diff[self.run].Da_err = Da 2757 self.relax.data.diff[self.run].theta_err = theta 2758 self.relax.data.diff[self.run].phi_err = phi 2759 2760 # Simulation values. 2761 else: 2762 # Create the data structure if it doesn't exist. 2763 if not hasattr(self.relax.data.diff[self.run], 'tm_sim'): 2764 self.relax.data.diff[self.run].tm_sim = [] 2765 if not hasattr(self.relax.data.diff[self.run], 'Da_sim'): 2766 self.relax.data.diff[self.run].Da_sim = [] 2767 if not hasattr(self.relax.data.diff[self.run], 'theta_sim'): 2768 self.relax.data.diff[self.run].theta_sim = [] 2769 if not hasattr(self.relax.data.diff[self.run], 'phi_sim'): 2770 self.relax.data.diff[self.run].phi_sim = [] 2771 2772 # Append the value. 2773 self.relax.data.diff[self.run].tm_sim.append(tm) 2774 self.relax.data.diff[self.run].Da_sim.append(Da) 2775 self.relax.data.diff[self.run].theta_sim.append(theta) 2776 self.relax.data.diff[self.run].phi_sim.append(phi) 2777 2778 2779 # Ellipsoid. 2780 elif diff_type == 'ellipsoid': 2781 # Convert the parameters to floating point numbers. 2782 try: 2783 tm = float(self.file_line[self.col['tm']]) 2784 Da = float(self.file_line[self.col['da']]) 2785 Dr = float(self.file_line[self.col['dr']]) 2786 alpha = float(self.file_line[self.col['alpha']]) / 360.0 * 2.0 * pi 2787 beta = float(self.file_line[self.col['beta']]) / 360.0 * 2.0 * pi 2788 gamma = float(self.file_line[self.col['gamma']]) / 360.0 * 2.0 * pi 2789 except ValueError: 2790 # Errors or simulation values set to None. 2791 if self.data_set != 'value' and self.file_line[self.col['tm']] == 'None': 2792 return 2793 2794 # Genuine error. 2795 raise RelaxError, "The diffusion tensor parameters are not numbers." 2796 2797 # Values. 2798 if self.data_set == 'value': 2799 diff_params = [tm, Da, Dr, alpha, beta, gamma] 2800 2801 # Errors. 2802 elif self.data_set == 'error': 2803 self.relax.data.diff[self.run].tm_err = tm 2804 self.relax.data.diff[self.run].Da_err = Da 2805 self.relax.data.diff[self.run].Dr_err = Dr 2806 self.relax.data.diff[self.run].alpha_err = alpha 2807 self.relax.data.diff[self.run].beta_err = beta 2808 self.relax.data.diff[self.run].gamma_err = gamma 2809 2810 # Simulation values. 2811 else: 2812 # Create the data structure if it doesn't exist. 2813 if not hasattr(self.relax.data.diff[self.run], 'tm_sim'): 2814 self.relax.data.diff[self.run].tm_sim = [] 2815 if not hasattr(self.relax.data.diff[self.run], 'Da_sim'): 2816 self.relax.data.diff[self.run].Da_sim = [] 2817 if not hasattr(self.relax.data.diff[self.run], 'Dr_sim'): 2818 self.relax.data.diff[self.run].Dr_sim = [] 2819 if not hasattr(self.relax.data.diff[self.run], 'alpha_sim'): 2820 self.relax.data.diff[self.run].alpha_sim = [] 2821 if not hasattr(self.relax.data.diff[self.run], 'beta_sim'): 2822 self.relax.data.diff[self.run].beta_sim = [] 2823 if not hasattr(self.relax.data.diff[self.run], 'gamma_sim'): 2824 self.relax.data.diff[self.run].gamma_sim = [] 2825 2826 # Append the value. 2827 self.relax.data.diff[self.run].tm_sim.append(tm) 2828 self.relax.data.diff[self.run].Da_sim.append(Da) 2829 self.relax.data.diff[self.run].Dr_sim.append(Dr) 2830 self.relax.data.diff[self.run].alpha_sim.append(alpha) 2831 self.relax.data.diff[self.run].beta_sim.append(beta) 2832 self.relax.data.diff[self.run].gamma_sim.append(gamma) 2833 2834 2835 # Set the diffusion tensor. 2836 if self.data_set == 'value' and diff_type: 2837 # Sort out the spheroid type. 2838 spheroid_type = None 2839 if diff_type == 'oblate' or diff_type == 'prolate': 2840 spheroid_type = diff_type 2841 2842 # Set the diffusion tensor. 2843 self.relax.generic.diffusion_tensor.init(run=self.run, params=diff_params, angle_units='rad', spheroid_type=spheroid_type)

2844 2845

2846 - def read_columnar_find_index(self):

2847 """Function for generating the sequence and or returning the residue index.""" 2848 2849 # Residue number and name. 2850 try: 2851 self.res_num = int(self.file_line[self.col['num']]) 2852 except ValueError: 2853 raise RelaxError, "The residue number " + self.file_line[self.col['num']] + " is not an integer." 2854 self.res_name = self.file_line[self.col['name']] 2855 2856 # Find the residue index. 2857 res_index = None 2858 for j in xrange(len(self.relax.data.res[self.run])): 2859 if self.relax.data.res[self.run][j].num == self.res_num and self.relax.data.res[self.run][j].name == self.res_name: 2860 res_index = j 2861 break 2862 if res_index == None: 2863 raise RelaxError, "Residue " + `self.res_num` + " " + self.res_name + " cannot be found in the sequence." 2864 2865 # Return the index. 2866 return res_index

2867 2868

2869 - def read_columnar_model_free_data(self):

2870 """Function for reading the model-free data.""" 2871 2872 # Reassign data structure. 2873 data = self.relax.data.res[self.run][self.res_index] 2874 2875 # Set up the model-free models. 2876 if self.data_set == 'value': 2877 model = self.file_line[self.col['model']] 2878 equation = self.file_line[self.col['eqi']] 2879 params = eval(self.file_line[self.col['params']]) 2880 if model and equation and params: 2881 self.model_setup(self.run, model=model, equation=equation, params=params, res_num=self.res_num) 2882 2883 # Values. 2884 if self.data_set == 'value': 2885 # S2. 2886 try: 2887 data.s2 = float(self.file_line[self.col['s2']]) * self.return_conversion_factor('s2') 2888 except ValueError: 2889 data.s2 = None 2890 2891 # S2f. 2892 try: 2893 data.s2f = float(self.file_line[self.col['s2f']]) * self.return_conversion_factor('s2f') 2894 except ValueError: 2895 data.s2f = None 2896 2897 # S2s. 2898 try: 2899 data.s2s = float(self.file_line[self.col['s2s']]) * self.return_conversion_factor('s2s') 2900 except ValueError: 2901 data.s2s = None 2902 2903 # Local tm. 2904 try: 2905 data.tm = float(self.file_line[self.col['local_tm']]) * self.return_conversion_factor('tm') 2906 except ValueError: 2907 data.tm = None 2908 2909 # te. 2910 try: 2911 data.te = float(self.file_line[self.col['te']]) * self.return_conversion_factor('te') 2912 except ValueError: 2913 data.te = None 2914 2915 # tf. 2916 try: 2917 data.tf = float(self.file_line[self.col['tf']]) * self.return_conversion_factor('tf') 2918 except ValueError: 2919 data.tf = None 2920 2921 # ts. 2922 try: 2923 data.ts = float(self.file_line[self.col['ts']]) * self.return_conversion_factor('ts') 2924 except ValueError: 2925 data.ts = None 2926 2927 # Rex. 2928 try: 2929 data.rex = float(self.file_line[self.col['rex']]) * self.return_conversion_factor('rex') 2930 except ValueError: 2931 data.rex = None 2932 2933 # Bond length. 2934 try: 2935 data.r = float(self.file_line[self.col['r']]) * self.return_conversion_factor('r') 2936 except ValueError: 2937 data.r = None 2938 2939 # CSA. 2940 try: 2941 data.csa = float(self.file_line[self.col['csa']]) * self.return_conversion_factor('csa') 2942 except ValueError: 2943 data.csa = None 2944 2945 # Minimisation details (global minimisation results). 2946 if self.param_set == 'diff' or self.param_set == 'all': 2947 self.relax.data.chi2[self.run] = eval(self.file_line[self.col['chi2']]) 2948 self.relax.data.iter[self.run] = eval(self.file_line[self.col['iter']]) 2949 self.relax.data.f_count[self.run] = eval(self.file_line[self.col['f_count']]) 2950 self.relax.data.g_count[self.run] = eval(self.file_line[self.col['g_count']]) 2951 self.relax.data.h_count[self.run] = eval(self.file_line[self.col['h_count']]) 2952 if self.file_line[self.col['warn']] == 'None': 2953 self.relax.data.warning[self.run] = None 2954 else: 2955 self.relax.data.warning[self.run] = replace(self.file_line[self.col['warn']], '_', ' ') 2956 2957 # Minimisation details (individual residue results). 2958 else: 2959 data.chi2 = eval(self.file_line[self.col['chi2']]) 2960 data.iter = eval(self.file_line[self.col['iter']]) 2961 data.f_count = eval(self.file_line[self.col['f_count']]) 2962 data.g_count = eval(self.file_line[self.col['g_count']]) 2963 data.h_count = eval(self.file_line[self.col['h_count']]) 2964 if self.file_line[self.col['warn']] == 'None': 2965 data.warning = None 2966 else: 2967 data.warning = replace(self.file_line[self.col['warn']], '_', ' ') 2968 2969 # Errors. 2970 if self.data_set == 'error': 2971 # S2. 2972 try: 2973 data.s2_err = float(self.file_line[self.col['s2']]) * self.return_conversion_factor('s2') 2974 except ValueError: 2975 data.s2_err = None 2976 2977 # S2f. 2978 try: 2979 data.s2f_err = float(self.file_line[self.col['s2f']]) * self.return_conversion_factor('s2f') 2980 except ValueError: 2981 data.s2f_err = None 2982 2983 # S2s. 2984 try: 2985 data.s2s_err = float(self.file_line[self.col['s2s']]) * self.return_conversion_factor('s2s') 2986 except ValueError: 2987 data.s2s_err = None 2988 2989 # Local tm. 2990 try: 2991 data.tm_err = float(self.file_line[self.col['local_tm']]) * self.return_conversion_factor('tm') 2992 except ValueError: 2993 data.tm_err = None 2994 2995 # te. 2996 try: 2997 data.te_err = float(self.file_line[self.col['te']]) * self.return_conversion_factor('te') 2998 except ValueError: 2999 data.te_err = None 3000 3001 # tf. 3002 try: 3003 data.tf_err = float(self.file_line[self.col['tf']]) * self.return_conversion_factor('tf') 3004 except ValueError: 3005 data.tf_err = None 3006 3007 # ts. 3008 try: 3009 data.ts_err = float(self.file_line[self.col['ts']]) * self.return_conversion_factor('ts') 3010 except ValueError: 3011 data.ts_err = None 3012 3013 # Rex. 3014 try: 3015 data.rex_err = float(self.file_line[self.col['rex']]) * self.return_conversion_factor('rex') 3016 except ValueError: 3017 data.rex_err = None 3018 3019 # Bond length. 3020 try: 3021 data.r_err = float(self.file_line[self.col['r']]) * self.return_conversion_factor('r') 3022 except ValueError: 3023 data.r_err = None 3024 3025 # CSA. 3026 try: 3027 data.csa_err = float(self.file_line[self.col['csa']]) * self.return_conversion_factor('csa') 3028 except ValueError: 3029 data.csa_err = None 3030 3031 3032 # Construct the simulation data structures. 3033 if self.data_set == 'sim_0': 3034 # Get the parameter object names. 3035 param_names = self.data_names(set='params') 3036 3037 # Get the minimisation statistic object names. 3038 min_names = self.data_names(set='min') 3039 3040 # Loop over all the parameter names. 3041 for object_name in param_names: 3042 # Name for the simulation object. 3043 sim_object_name = object_name + '_sim' 3044 3045 # Create the simulation object. 3046 setattr(data, sim_object_name, []) 3047 3048 # Loop over all the minimisation object names. 3049 for object_name in min_names: 3050 # Name for the simulation object. 3051 sim_object_name = object_name + '_sim' 3052 3053 # Create the simulation object. 3054 if self.param_set == 'diff' or self.param_set == 'all': 3055 setattr(self.relax.data, sim_object_name, {}) 3056 object = getattr(self.relax.data, sim_object_name) 3057 object[self.run] = [] 3058 else: 3059 setattr(data, sim_object_name, []) 3060 3061 # Simulations. 3062 if self.data_set != 'value' and self.data_set != 'error': 3063 # S2. 3064 try: 3065 data.s2_sim.append(float(self.file_line[self.col['s2']]) * self.return_conversion_factor('s2')) 3066 except ValueError: 3067 data.s2_sim.append(None) 3068 3069 # S2f. 3070 try: 3071 data.s2f_sim.append(float(self.file_line[self.col['s2f']]) * self.return_conversion_factor('s2f')) 3072 except ValueError: 3073 data.s2f_sim.append(None) 3074 3075 # S2s. 3076 try: 3077 data.s2s_sim.append(float(self.file_line[self.col['s2s']]) * self.return_conversion_factor('s2s')) 3078 except ValueError: 3079 data.s2s_sim.append(None) 3080 3081 # Local tm. 3082 try: 3083 data.tm_sim.append(float(self.file_line[self.col['local_tm']]) * self.return_conversion_factor('tm')) 3084 except ValueError: 3085 data.tm_sim.append(None) 3086 3087 # te. 3088 try: 3089 data.te_sim.append(float(self.file_line[self.col['te']]) * self.return_conversion_factor('te')) 3090 except ValueError: 3091 data.te_sim.append(None) 3092 3093 # tf. 3094 try: 3095 data.tf_sim.append(float(self.file_line[self.col['tf']]) * self.return_conversion_factor('tf')) 3096 except ValueError: 3097 data.tf_sim.append(None) 3098 3099 # ts. 3100 try: 3101 data.ts_sim.append(float(self.file_line[self.col['ts']]) * self.return_conversion_factor('ts')) 3102 except ValueError: 3103 data.ts_sim.append(None) 3104 3105 # Rex. 3106 try: 3107 data.rex_sim.append(float(self.file_line[self.col['rex']]) * self.return_conversion_factor('rex')) 3108 except ValueError: 3109 data.rex_sim.append(None) 3110 3111 # Bond length. 3112 try: 3113 data.r_sim.append(float(self.file_line[self.col['r']]) * self.return_conversion_factor('r')) 3114 except ValueError: 3115 data.r_sim.append(None) 3116 3117 # CSA. 3118 try: 3119 data.csa_sim.append(float(self.file_line[self.col['csa']]) * self.return_conversion_factor('csa')) 3120 except ValueError: 3121 data.csa_sim.append(None) 3122 3123 # Minimisation details (global minimisation results). 3124 if self.param_set == 'diff' or self.param_set == 'all': 3125 self.relax.data.chi2_sim[self.run].append(eval(self.file_line[self.col['chi2']])) 3126 self.relax.data.iter_sim[self.run].append(eval(self.file_line[self.col['iter']])) 3127 self.relax.data.f_count_sim[self.run].append(eval(self.file_line[self.col['f_count']])) 3128 self.relax.data.g_count_sim[self.run].append(eval(self.file_line[self.col['g_count']])) 3129 self.relax.data.h_count_sim[self.run].append(eval(self.file_line[self.col['h_count']])) 3130 if self.file_line[self.col['warn']] == 'None': 3131 self.relax.data.warning_sim[self.run].append(None) 3132 else: 3133 self.relax.data.warning_sim[self.run].append(replace(self.file_line[self.col['warn']], '_', ' ')) 3134 3135 # Minimisation details (individual residue results). 3136 else: 3137 data.chi2_sim.append(eval(self.file_line[self.col['chi2']])) 3138 data.iter_sim.append(eval(self.file_line[self.col['iter']])) 3139 data.f_count_sim.append(eval(self.file_line[self.col['f_count']])) 3140 data.g_count_sim.append(eval(self.file_line[self.col['g_count']])) 3141 data.h_count_sim.append(eval(self.file_line[self.col['h_count']])) 3142 if self.file_line[self.col['warn']] == 'None': 3143 data.warning_sim.append(None) 3144 else: 3145 data.warning_sim.append(replace(self.file_line[self.col['warn']], '_', ' '))

3146 3147

3148 - def read_columnar_param_set(self):

3149 """Function for reading the parameter set.""" 3150 3151 # Extract the parameter set if it exists, otherwise return. 3152 if self.file_line[self.col['param_set']] != 'None': 3153 self.param_set = self.file_line[self.col['param_set']] 3154 else: 3155 return 3156 3157 # Local tm and model-free only parameter sets. 3158 if self.param_set == 'local_tm' or self.param_set == 'mf': 3159 diff_fixed = 1 3160 res_fixed = 0 3161 3162 # Diffusion tensor parameter set. 3163 elif self.param_set == 'diff': 3164 diff_fixed = 0 3165 res_fixed = 1 3166 3167 # 'all' parameter set. 3168 elif self.param_set == 'all': 3169 diff_fixed = 0 3170 res_fixed = 0 3171 3172 # No parameter set. 3173 elif self.param_set == 'None': 3174 self.param_set = None 3175 diff_fixed = None 3176 res_fixed = None 3177 3178 # Set the diffusion tensor fixed flag. 3179 if self.param_set != 'local_tm' and diff_fixed != None: 3180 self.relax.data.diff[self.run].fixed = diff_fixed 3181 3182 # Set the residue specific fixed flag. 3183 for i in xrange(len(self.relax.data.res[self.run])): 3184 if res_fixed != None: 3185 self.relax.data.res[self.run][i].fixed = res_fixed

3186 3187

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

3189 """Function for reading the PDB file.""" 3190 3191 # File name. 3192 pdb = self.file_line[self.col['pdb']] 3193 3194 # PDB model. 3195 pdb_model = eval(self.file_line[self.col['pdb_model']]) 3196 3197 # Heteronucleus. 3198 if self.col.has_key('pdb_heteronuc'): 3199 pdb_heteronuc = self.file_line[self.col['pdb_heteronuc']] 3200 3201 # Proton. 3202 if self.col.has_key('pdb_proton'): 3203 pdb_proton = self.file_line[self.col['pdb_proton']] 3204 3205 # Load the PDB. 3206 if not pdb == 'None': 3207 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) 3208 return 1 3209 else: 3210 return 0

3211 3212

3213 - def read_columnar_relax_data(self):

3214 """Function for reading the relaxation data.""" 3215 3216 # Skip the error 'data_set'. 3217 if self.data_set == 'error': 3218 return 3219 3220 # Relaxation data structures. 3221 if not self.ri_labels: 3222 self.ri_labels = eval(self.file_line[self.col['ri_labels']]) 3223 self.remap_table = eval(self.file_line[self.col['remap_table']]) 3224 self.frq_labels = eval(self.file_line[self.col['frq_labels']]) 3225 self.frq = eval(self.file_line[self.col['frq']]) 3226 3227 # Test if the relaxation data is consistent. 3228 if self.ri_labels != eval(self.file_line[self.col['ri_labels']]) or self.remap_table != eval(self.file_line[self.col['remap_table']]) or self.frq_labels != eval(self.file_line[self.col['frq_labels']]) or self.frq != eval(self.file_line[self.col['frq']]): 3229 raise RelaxError, "The relaxation data is not consistent for all residues." 3230 3231 # No relaxation data. 3232 if not self.ri_labels: 3233 return 3234 3235 # Initialise the value and error arrays. 3236 values = [] 3237 errors = [] 3238 3239 # Loop over the relaxation data of the residue. 3240 for i in xrange(len(self.ri_labels)): 3241 # Determine the data and error columns for this relaxation data set. 3242 data_col = self.col['frq'] + i + 1 3243 error_col = self.col['frq'] + len(self.ri_labels) + i + 1 3244 3245 # Append the value and error. 3246 values.append(eval(self.file_line[data_col])) 3247 errors.append(eval(self.file_line[error_col])) 3248 3249 # Simulations. 3250 sim = 0 3251 if self.data_set != 'value' and self.data_set != 'error': 3252 sim = 1 3253 3254 # Add the relaxation data. 3255 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)

3256 3257

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

3259 """Function for reading the results file.""" 3260 3261 # Arguments. 3262 self.run = run 3263 3264 # Extract and remove the header. 3265 header = file_data[0] 3266 file_data = file_data[1:] 3267 3268 # Sort the column numbers. 3269 self.read_columnar_col_numbers(header) 3270 3271 # Test the file. 3272 if len(self.col) < 2: 3273 raise RelaxInvalidDataError 3274 3275 # Initialise some data structures and flags. 3276 nucleus_set = 0 3277 sim_num = None 3278 sims = [] 3279 select_sim = [] 3280 diff_data_set = 0 3281 diff_error_set = 0 3282 diff_sim_set = None 3283 self.param_set = None 3284 pdb = 0 3285 pdb_model = None 3286 pdb_heteronuc = None 3287 pdb_proton = None 3288 self.ri_labels = None 3289 3290 # Generate the sequence. 3291 for self.file_line in file_data: 3292 # The data set. 3293 self.data_set = self.file_line[self.col['data_set']] 3294 3295 # Stop creating the sequence once the data_set is no longer 'value'. 3296 if self.data_set != 'value': 3297 break 3298 3299 # Sequence. 3300 self.read_columnar_sequence() 3301 3302 3303 # Loop over the lines of the file data. 3304 for self.file_line in file_data: 3305 # The data set. 3306 self.data_set = self.file_line[self.col['data_set']] 3307 3308 # Find the residue index. 3309 self.res_index = self.read_columnar_find_index() 3310 3311 # Reassign data structure. 3312 data = self.relax.data.res[self.run][self.res_index] 3313 3314 # Skip unselected residues. 3315 if not data.select: 3316 continue 3317 3318 # Set the nucleus type. 3319 if not nucleus_set: 3320 if self.file_line[self.col['nucleus']] != 'None': 3321 self.relax.generic.nuclei.set_values(self.file_line[self.col['nucleus']]) 3322 nucleus_set = 1 3323 3324 # Simulation number. 3325 if self.data_set != 'value' and self.data_set != 'error': 3326 # Extract the number from the self.data_set string. 3327 sim_num = split(self.data_set, '_') 3328 try: 3329 sim_num = int(sim_num[1]) 3330 except: 3331 raise RelaxError, "The simulation number '%s' is invalid." % sim_num 3332 3333 # Update the sims array. 3334 sims.append(sim_num) 3335 3336 # Selected simulations. 3337 select_sim.append(self.file_line[self.col['select']]) 3338 3339 # Diffusion tensor data. 3340 if self.data_set == 'value' and not diff_data_set: 3341 self.read_columnar_diff_tensor() 3342 diff_data_set = 1 3343 3344 # Diffusion tensor errors. 3345 elif self.data_set == 'error' and not diff_error_set: 3346 self.read_columnar_diff_tensor() 3347 diff_error_set = 1 3348 3349 # Diffusion tensor simulation data. 3350 elif self.data_set != 'value' and self.data_set != 'error' and sim_num != diff_sim_set: 3351 self.read_columnar_diff_tensor() 3352 diff_sim_set = sim_num 3353 3354 # Parameter set. 3355 if self.param_set == None: 3356 self.read_columnar_param_set() 3357 3358 # PDB. 3359 if not pdb: 3360 if self.read_columnar_pdb(print_flag): 3361 pdb = 1 3362 3363 # XH vector. 3364 if self.data_set == 'value': 3365 self.read_columnar_xh_vect() 3366 3367 # Relaxation data. 3368 self.read_columnar_relax_data() 3369 3370 # Model-free data. 3371 self.read_columnar_model_free_data() 3372 3373 # Set up the simulations. 3374 if len(sims): 3375 self.relax.generic.monte_carlo.setup(self.run, select_sim=select_sim)

3376 3377

3378 - def read_columnar_sequence(self):

3379 """Function for generating the sequence.""" 3380 3381 # Residue number and name. 3382 try: 3383 res_num = int(self.file_line[self.col['num']]) 3384 except ValueError: 3385 raise RelaxError, "The residue number " + self.file_line[self.col['num']] + " is not an integer." 3386 res_name = self.file_line[self.col['name']] 3387 3388 # Generate the sequence. 3389 self.relax.generic.sequence.add(self.run, res_num, res_name, select=int(self.file_line[self.col['select']]))

3390 3391

3392 - def read_columnar_xh_vect(self):

3393 """Function for reading the XH unit vectors.""" 3394 3395 # The vector. 3396 xh_vect = eval(self.file_line[self.col['xh_vect']]) 3397 if xh_vect: 3398 # Numeric array format. 3399 try: 3400 xh_vect = array(xh_vect, Float64) 3401 except: 3402 raise RelaxError, "The XH unit vector " + self.file_line[self.col['xh_vect']] + " is invalid." 3403 3404 # Set the vector. 3405 self.relax.generic.pdb.set_vector(run=self.run, res=self.res_index, xh_vect=xh_vect)

3406 3407

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

3409 """Function for removing the local tm parameter from the model-free parameters.""" 3410 3411 # Arguments. 3412 self.run = run 3413 3414 # Test if the run exists. 3415 if not self.run in self.relax.data.run_names: 3416 raise RelaxNoRunError, self.run 3417 3418 # Test if the run type is set to 'mf'. 3419 function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 3420 if function_type != 'mf': 3421 raise RelaxFuncSetupError, self.relax.specific_setup.get_string(function_type) 3422 3423 # Test if sequence data is loaded. 3424 if not self.relax.data.res.has_key(self.run): 3425 raise RelaxNoSequenceError, self.run 3426 3427 # Loop over the sequence. 3428 for i in xrange(len(self.relax.data.res[self.run])): 3429 # Remap the data structure. 3430 data = self.relax.data.res[self.run][i] 3431 3432 # Skip unselected residues. 3433 if not data.select: 3434 continue 3435 3436 # If res_num is set, then skip all other residues. 3437 if res_num != None and res_num != data.num: 3438 continue 3439 3440 # Test if a local tm parameter exists. 3441 if not hasattr(data, 'params') or not 'tm' in data.params: 3442 continue 3443 3444 # Remove tm. 3445 data.params.remove('tm') 3446 3447 # Model name. 3448 if match('^tm', data.model): 3449 data.model = data.model[1:] 3450 3451 # Set the tm value to None. 3452 data.tm = None 3453 3454 # Set all the minimisation details to None. 3455 data.chi2 = None 3456 data.iter = None 3457 data.f_count = None 3458 data.g_count = None 3459 data.h_count = None 3460 data.warning = None 3461 3462 # Set the global minimisation details to None. 3463 self.relax.data.chi2[self.run] = None 3464 self.relax.data.iter[self.run] = None 3465 self.relax.data.f_count[self.run] = None 3466 self.relax.data.g_count[self.run] = None 3467 self.relax.data.h_count[self.run] = None 3468 self.relax.data.warning[self.run] = None

3469 3470

3471 - def return_conversion_factor(self, param):

3472 """Function for returning the factor of conversion between different parameter units. 3473 3474 For example, the internal representation of te is in seconds, whereas the external 3475 representation is in picoseconds, therefore this function will return 1e-12 for te. 3476 """ 3477 3478 # Get the object name. 3479 object_name = self.return_data_name(param) 3480 3481 # tm (nanoseconds). 3482 if object_name == 'tm': 3483 return 1e-9 3484 3485 # te, tf, and ts (picoseconds). 3486 elif object_name in ['te', 'tf', 'ts']: 3487 return 1e-12 3488 3489 # Rex (value at 1st field strength). 3490 elif object_name == 'rex': 3491 return 1.0 / (2.0 * pi * self.relax.data.frq[self.run][0])**2 3492 3493 # Bond length (Angstrom). 3494 elif object_name == 'r': 3495 return 1e-10 3496 3497 # CSA (ppm). 3498 elif object_name == 'csa': 3499 return 1e-6 3500 3501 # No conversion factor. 3502 else: 3503 return 1.0

3504 3505

3506 - def return_data_name(self, name):

3507 """ 3508 Model-free data type string matching patterns 3509 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 3510 3511 ____________________________________________________________________________________________ 3512 | | | | 3513 | Data type | Object name | Patterns | 3514 |________________________|______________|__________________________________________________| 3515 | | | | 3516 | Local tm | 'tm' | '^tm$' | 3517 | | | | 3518 | Order parameter S2 | 's2' | '^[Ss]2$' | 3519 | | | | 3520 | Order parameter S2f | 's2f' | '^[Ss]2f$' | 3521 | | | | 3522 | Order parameter S2s | 's2s' | '^[Ss]2s$' | 3523 | | | | 3524 | Correlation time te | 'te' | '^te$' | 3525 | | | | 3526 | Correlation time tf | 'tf' | '^tf$' | 3527 | | | | 3528 | Correlation time ts | 'ts' | '^ts$' | 3529 | | | | 3530 | Chemical exchange | 'rex' | '^[Rr]ex$' or '[Cc]emical[ -_][Ee]xchange' | 3531 | | | | 3532 | Bond length | 'r' | '^r$' or '[Bb]ond[ -_][Ll]ength' | 3533 | | | | 3534 | CSA | 'csa' | '^[Cc][Ss][Aa]$' | 3535 |________________________|______________|__________________________________________________| 3536 3537 """ 3538 3539 # Local tm. 3540 if search('^tm$', name): 3541 return 'tm' 3542 3543 # Order parameter S2. 3544 if search('^[Ss]2$', name): 3545 return 's2' 3546 3547 # Order parameter S2f. 3548 if search('^[Ss]2f$', name): 3549 return 's2f' 3550 3551 # Order parameter S2s. 3552 if search('^[Ss]2s$', name): 3553 return 's2s' 3554 3555 # Correlation time te. 3556 if search('^te$', name): 3557 return 'te' 3558 3559 # Correlation time tf. 3560 if search('^tf$', name): 3561 return 'tf' 3562 3563 # Correlation time ts. 3564 if search('^ts$', name): 3565 return 'ts' 3566 3567 # Rex. 3568 if search('^[Rr]ex$', name) or search('[Cc]emical[ -_][Ee]xchange', name): 3569 return 'rex' 3570 3571 # Bond length. 3572 if search('^r$', name) or search('[Bb]ond[ -_][Ll]ength', name): 3573 return 'r' 3574 3575 # CSA. 3576 if search('^[Cc][Ss][Aa]$', name): 3577 return 'csa'

3578 3579

3580 - def return_grace_string(self, param):

3581 """Function for returning the Grace string representing the parameter for axis labelling.""" 3582 3583 # Get the object name. 3584 object_name = self.return_data_name(param) 3585 3586 # Local tm. 3587 if object_name == 'tm': 3588 return '\\xt\\f{}\\sm' 3589 3590 # Order parameter S2. 3591 elif object_name == 's2': 3592 return '\\qS\\v{0.4}\\z{0.71}2\\Q' 3593 3594 # Order parameter S2f. 3595 elif object_name == 's2f': 3596 return '\\qS\\sf\\N\\h{-0.2}\\v{0.4}\\z{0.71}2\\Q' 3597 3598 # Order parameter S2s. 3599 elif object_name == 's2s': 3600 return '\\qS\\ss\\N\\h{-0.2}\\v{0.4}\\z{0.71}2\\Q' 3601 3602 # Correlation time te. 3603 elif object_name == 'te': 3604 return '\\xt\\f{}\\se' 3605 3606 # Correlation time tf. 3607 elif object_name == 'tf': 3608 return '\\xt\\f{}\\sf' 3609 3610 # Correlation time ts. 3611 elif object_name == 'ts': 3612 return '\\xt\\f{}\\ss' 3613 3614 # Rex. 3615 elif object_name == 'rex': 3616 return '\\qR\\sex\\Q' 3617 3618 # Bond length. 3619 elif object_name == 'r': 3620 return 'Bond length' 3621 3622 # CSA. 3623 elif object_name == 'csa': 3624 return '\\qCSA\\Q'

3625 3626

3627 - def return_units(self, param):

3628 """Function for returning a string representing the parameters units. 3629 3630 For example, the internal representation of te is in seconds, whereas the external 3631 representation is in picoseconds, therefore this function will return the string 3632 'picoseconds' for te. 3633 """ 3634 3635 # Get the object name. 3636 object_name = self.return_data_name(param) 3637 3638 # tm (nanoseconds). 3639 if object_name == 'tm': 3640 return 'ns' 3641 3642 # te, tf, and ts (picoseconds). 3643 elif object_name in ['te', 'tf', 'ts']: 3644 return 'ps' 3645 3646 # Rex (value at 1st field strength). 3647 elif object_name == 'rex': 3648 return self.relax.data.frq_labels[self.run][0] + ' MHz' 3649 3650 # Bond length (Angstrom). 3651 elif object_name == 'r': 3652 return 'Angstrom' 3653 3654 # CSA (ppm). 3655 elif object_name == 'csa': 3656 return 'ppm'

3657 3658

3659 - def return_value(self, run, i, param, sim=None):

3660 """Function for returning the value and error corresponding to 'param'. 3661 3662 If sim is set to an integer, return the value of the simulation and None. 3663 """ 3664 3665 # Arguments. 3666 self.run = run 3667 3668 # Get the object name. 3669 object_name = self.return_data_name(param) 3670 3671 # The data type does not exist. 3672 if not object_name: 3673 raise RelaxError, "The model-free parameter " + `param` + " does not exist." 3674 3675 # The error and simulation names. 3676 object_error = object_name + '_err' 3677 object_sim = object_name + '_sim' 3678 3679 # Value and error. 3680 if sim == None: 3681 # Get the value. 3682 if hasattr(self.relax.data.res[self.run][i], object_name): 3683 value = getattr(self.relax.data.res[self.run][i], object_name) 3684 else: 3685 value = None 3686 3687 # Get the error. 3688 if hasattr(self.relax.data.res[self.run][i], object_error): 3689 error = getattr(self.relax.data.res[self.run][i], object_error) 3690 else: 3691 error = None 3692 3693 # Return the data. 3694 return value, error 3695 3696 # Simulation value. 3697 else: 3698 # Get the value. 3699 if hasattr(self.relax.data.res[self.run][i], object_sim): 3700 object = getattr(self.relax.data.res[self.run][i], object_sim) 3701 value = object[sim] 3702 else: 3703 value = None 3704 3705 # Return the data. 3706 return value, None

3707 3708

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

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

3998 3999

4000 - def set(self, run=None, value=None, error=None, param=None, scaling=1.0, index=None):

4001 """ 4002 Model-free set details 4003 ~~~~~~~~~~~~~~~~~~~~~~ 4004 4005 Setting a parameter value may have no effect depending on which model-free model is chosen, 4006 for example if S2f values and S2s values are set but the run corresponds to model-free model 4007 'm4' then, because these data values are not parameters of the model, they will have no 4008 effect. 4009 4010 Note that the Rex values are scaled quadratically with field strength and should be supplied 4011 as a field strength independent value. Use the following formula to get the correct value: 4012 4013 value = Rex / (2.0 * pi * frequency) ** 2 4014 4015 where: 4016 Rex is the chemical exchange value for the current frequency. 4017 pi is in the namespace of relax, ie just type 'pi'. 4018 frequency is the proton frequency corresponding to the data. 4019 """ 4020 4021 # Arguments. 4022 self.run = run 4023 4024 # Setting the model parameters prior to minimisation. 4025 ##################################################### 4026 4027 if param == None: 4028 # The values are supplied by the user: 4029 if value: 4030 # Test if the length of the value array is equal to the length of the model-free parameter array. 4031 if len(value) != len(self.relax.data.res[self.run][index].params): 4032 raise RelaxError, "The length of " + `len(value)` + " of the value array must be equal to the length of the model-free parameter array, " + `self.relax.data.res[self.run][index].params` + ", for residue " + `self.relax.data.res[self.run][index].num` + " " + self.relax.data.res[self.run][index].name + "." 4033 4034 # Default values. 4035 else: 4036 # Set 'value' to an empty array. 4037 value = [] 4038 4039 # Loop over the model-free parameters. 4040 for i in xrange(len(self.relax.data.res[self.run][index].params)): 4041 value.append(self.default_value(self.relax.data.res[self.run][index].params[i])) 4042 4043 # Loop over the model-free parameters. 4044 for i in xrange(len(self.relax.data.res[self.run][index].params)): 4045 # Get the object. 4046 object_name = self.return_data_name(self.relax.data.res[self.run][index].params[i]) 4047 if not object_name: 4048 raise RelaxError, "The model-free data type " + `self.relax.data.res[self.run][index].params[i]` + " does not exist." 4049 4050 # Initialise all data if it doesn't exist. 4051 if not hasattr(self.relax.data.res[self.run][index], object_name): 4052 self.data_init(self.relax.data.res[self.run][index]) 4053 4054 # Set the value. 4055 setattr(self.relax.data.res[self.run][index], object_name, float(value[i]) * scaling) 4056 4057 4058 # Individual data type. 4059 ####################### 4060 4061 else: 4062 # Get the object. 4063 object_name = self.return_data_name(param) 4064 if not object_name: 4065 raise RelaxError, "The model-free data type " + `param` + " does not exist." 4066 4067 # Initialise all data if it doesn't exist. 4068 if not hasattr(self.relax.data.res[self.run][index], object_name): 4069 self.data_init(self.relax.data.res[self.run][index]) 4070 4071 # Default value. 4072 if value == None: 4073 value = self.default_value(object_name) 4074 4075 # Set the value. 4076 setattr(self.relax.data.res[self.run][index], object_name, float(value) * scaling) 4077 4078 # Set the error. 4079 if error != None: 4080 setattr(self.relax.data.res[self.run][index], object_name+'_error', float(error))

4081 4082

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

4084 """Function for setting parameter errors.""" 4085 4086 # Arguments. 4087 self.run = run 4088 4089 # Increment counter for the parameter set 'all'. 4090 inc = 0 4091 4092 # Get the parameter object names. 4093 param_names = self.data_names(set='params') 4094 4095 4096 # Diffusion tensor parameter errors. 4097 #################################### 4098 4099 if self.param_set == 'diff' or self.param_set == 'all': 4100 # Spherical diffusion. 4101 if self.relax.data.diff[self.run].type == 'sphere': 4102 # Return the parameter array. 4103 if index == 0: 4104 self.relax.data.diff[self.run].tm_err = error 4105 4106 # Increment. 4107 inc = inc + 1 4108 4109 # Spheroidal diffusion. 4110 elif self.relax.data.diff[self.run].type == 'spheroid': 4111 # Return the parameter array. 4112 if index == 0: 4113 self.relax.data.diff[self.run].tm_err = error 4114 elif index == 1: 4115 self.relax.data.diff[self.run].Da_err = error 4116 elif index == 2: 4117 self.relax.data.diff[self.run].theta_err = error 4118 elif index == 3: 4119 self.relax.data.diff[self.run].phi_err = error 4120 4121 # Increment. 4122 inc = inc + 4 4123 4124 # Ellipsoidal diffusion. 4125 elif self.relax.data.diff[self.run].type == 'ellipsoid': 4126 # Return the parameter array. 4127 if index == 0: 4128 self.relax.data.diff[self.run].tm_err = error 4129 elif index == 1: 4130 self.relax.data.diff[self.run].Da_err = error 4131 elif index == 2: 4132 self.relax.data.diff[self.run].Dr_err = error 4133 elif index == 3: 4134 self.relax.data.diff[self.run].alpha_err = error 4135 elif index == 4: 4136 self.relax.data.diff[self.run].beta_err = error 4137 elif index == 5: 4138 self.relax.data.diff[self.run].gamma_err = error 4139 4140 # Increment. 4141 inc = inc + 6 4142 4143 4144 # Model-free parameter errors for the parameter set 'all'. 4145 ########################################################## 4146 4147 if self.param_set == 'all': 4148 # Loop over the sequence. 4149 for i in xrange(len(self.relax.data.res[self.run])): 4150 # Skip unselected residues. 4151 if not self.relax.data.res[self.run][i].select: 4152 continue 4153 4154 # Loop over the residue specific parameters. 4155 for param in param_names: 4156 # Return the parameter array. 4157 if index == inc: 4158 setattr(self.relax.data.res[self.run][i], param + "_err", error) 4159 4160 # Increment. 4161 inc = inc + 1 4162 4163 4164 # Model-free parameters for the parameter sets 'mf' and 'local_tm'. 4165 ################################################################### 4166 4167 if self.param_set == 'mf' or self.param_set == 'local_tm': 4168 # Skip unselected residues. 4169 if not self.relax.data.res[self.run][instance].select: 4170 return 4171 4172 # Loop over the residue specific parameters. 4173 for param in param_names: 4174 # Return the parameter array. 4175 if index == inc: 4176 setattr(self.relax.data.res[self.run][instance], param + "_err", error) 4177 4178 # Increment. 4179 inc = inc + 1

4180 4181

4182 - def sim_init_values(self, run):

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

4337 4338

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

4340 """Function for returning the array of simulation chi-squared values.""" 4341 4342 # Arguments. 4343 self.run = run 4344 4345 # Determine the parameter set type. 4346 self.param_set = self.determine_param_set_type() 4347 4348 # Single instance. 4349 if self.param_set == 'all' or self.param_set == 'diff': 4350 return self.relax.data.chi2_sim[self.run] 4351 4352 # Multiple instances. 4353 else: 4354 return self.relax.data.res[self.run][instance].chi2_sim

4355 4356

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

4358 """Function for returning the array of simulation parameter values.""" 4359 4360 # Arguments. 4361 self.run = run 4362 4363 # Increment counter for the parameter set 'all'. 4364 inc = 0 4365 4366 # Get the parameter object names. 4367 param_names = self.data_names(set='params') 4368 4369 4370 # Diffusion tensor parameters. 4371 ############################## 4372 4373 if self.param_set == 'diff' or self.param_set == 'all': 4374 # Spherical diffusion. 4375 if self.relax.data.diff[self.run].type == 'sphere': 4376 # Return the parameter array. 4377 if index == 0: 4378 return self.relax.data.diff[self.run].tm_sim 4379 4380 # Increment. 4381 inc = inc + 1 4382 4383 # Spheroidal diffusion. 4384 elif self.relax.data.diff[self.run].type == 'spheroid': 4385 # Return the parameter array. 4386 if index == 0: 4387 return self.relax.data.diff[self.run].tm_sim 4388 elif index == 1: 4389 return self.relax.data.diff[self.run].Da_sim 4390 elif index == 2: 4391 return self.relax.data.diff[self.run].theta_sim 4392 elif index == 3: 4393 return self.relax.data.diff[self.run].phi_sim 4394 4395 # Increment. 4396 inc = inc + 4 4397 4398 # Ellipsoidal diffusion. 4399 elif self.relax.data.diff[self.run].type == 'ellipsoid': 4400 # Return the parameter array. 4401 if index == 0: 4402 return self.relax.data.diff[self.run].tm_sim 4403 elif index == 1: 4404 return self.relax.data.diff[self.run].Da_sim 4405 elif index == 2: 4406 return self.relax.data.diff[self.run].Dr_sim 4407 elif index == 3: 4408 return self.relax.data.diff[self.run].alpha_sim 4409 elif index == 4: 4410 return self.relax.data.diff[self.run].beta_sim 4411 elif index == 5: 4412 return self.relax.data.diff[self.run].gamma_sim 4413 4414 # Increment. 4415 inc = inc + 6 4416 4417 4418 # Model-free parameters for the parameter set 'all'. 4419 #################################################### 4420 4421 if self.param_set == 'all': 4422 # Loop over the sequence. 4423 for i in xrange(len(self.relax.data.res[self.run])): 4424 # Skip unselected residues. 4425 if not self.relax.data.res[self.run][i].select: 4426 continue 4427 4428 # Loop over the residue specific parameters. 4429 for param in param_names: 4430 # Return the parameter array. 4431 if index == inc: 4432 return getattr(self.relax.data.res[self.run][i], param + "_sim") 4433 4434 # Increment. 4435 inc = inc + 1 4436 4437 4438 # Model-free parameters for the parameter sets 'mf' and 'local_tm'. 4439 ################################################################### 4440 4441 if self.param_set == 'mf' or self.param_set == 'local_tm': 4442 # Skip unselected residues. 4443 if not self.relax.data.res[self.run][instance].select: 4444 return 4445 4446 # Loop over the residue specific parameters. 4447 for param in param_names: 4448 # Return the parameter array. 4449 if index == inc: 4450 return getattr(self.relax.data.res[self.run][instance], param + "_sim") 4451 4452 # Increment. 4453 inc = inc + 1

4454 4455

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

4457 """Function for returning the array of selected simulation flags.""" 4458 4459 # Arguments. 4460 self.run = run 4461 4462 # Determine the parameter set type. 4463 self.param_set = self.determine_param_set_type() 4464 4465 # Single instance. 4466 if self.param_set == 'all' or self.param_set == 'diff': 4467 return self.relax.data.select_sim[self.run] 4468 4469 # Multiple instances. 4470 else: 4471 return self.relax.data.res[self.run][instance].select_sim

4472 4473

4474 - def sim_set_selected(self, run, instance, select_sim):

4475 """Function for returning the array of selected simulation flags.""" 4476 4477 # Arguments. 4478 self.run = run 4479 4480 # Determine the parameter set type. 4481 self.param_set = self.determine_param_set_type() 4482 4483 # Single instance. 4484 if self.param_set == 'all' or self.param_set == 'diff': 4485 self.relax.data.select_sim = select_sim 4486 4487 # Multiple instances. 4488 else: 4489 self.relax.data.res[self.run][instance].select_sim = select_sim

4490 4491

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

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

4512 4513

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

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

4538 4539

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

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

4624 4625

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

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