generic_fns.value

30 - def __init__(self, relax):

31 """Class containing functions for the setting up of data structures.""" 32 33 self.relax = relax

34 35

36 - def copy(self, run1=None, run2=None, param=None):

37 """Function for copying residue specific data values from run1 to run2.""" 38 39 # Arguments. 40 self.param = param 41 42 # Test if run1 exists. 43 if not run1 in self.relax.data.run_names: 44 raise RelaxNoRunError, run1 45 46 # Test if run2 exists. 47 if not run2 in self.relax.data.run_names: 48 raise RelaxNoRunError, run2 49 50 # Test if the sequence data for run1 is loaded. 51 if not self.relax.data.res.has_key(run1): 52 raise RelaxNoSequenceError, run1 53 54 # Test if the sequence data for run2 is loaded. 55 if not self.relax.data.res.has_key(run2): 56 raise RelaxNoSequenceError, run2 57 58 # Function type. 59 self.function_type = self.relax.data.run_types[self.relax.data.run_names.index(run1)] 60 61 # Specific value and error returning function. 62 return_value = self.relax.specific_setup.setup('return_value', self.function_type) 63 64 # Specific set function. 65 set = self.relax.specific_setup.setup('set', self.function_type) 66 67 # Test if the data exists for run2. 68 for i in xrange(len(self.relax.data.res[run2])): 69 # Get the value and error for run2. 70 value, error = return_value(run2, i, param) 71 72 # Data exists. 73 if value != None or error != None: 74 raise RelaxValueError, (param, run2) 75 76 # Copy the values. 77 for i in xrange(len(self.relax.data.res[run1])): 78 # Get the value and error for run1. 79 value, error = return_value(run1, i, param) 80 81 # Set the values of run2. 82 set(run=run2, value=value, error=error, param=param, index=i) 83 84 # Reset the residue specific minimisation statistics. 85 self.relax.generic.minimise.reset_min_stats(run2, i) 86 87 # Reset the global minimisation statistics. 88 self.relax.generic.minimise.reset_min_stats(run2)

89 90

91 - def display(self, run=None, param=None):

92 """Function for displaying residue specific data values.""" 93 94 # Arguments. 95 self.run = run 96 self.param = param 97 98 # Test if the run exists. 99 if not self.run in self.relax.data.run_names: 100 raise RelaxNoRunError, self.run 101 102 # Test if the sequence data is loaded. 103 if not self.relax.data.res.has_key(self.run): 104 raise RelaxNoSequenceError, self.run 105 106 # Print the data. 107 self.write_data(run=run, param=param, file=sys.stdout)

108 109

110 - def read(self, run=None, param=None, scaling=1.0, file=None, num_col=0, name_col=1, data_col=2, error_col=3, sep=None):

111 """Function for reading residue specific data values from a file.""" 112 113 # Arguments. 114 self.run = run 115 self.param = param 116 self.scaling = scaling 117 118 # Test if the run exists. 119 if not self.run in self.relax.data.run_names: 120 raise RelaxNoRunError, self.run 121 122 # Test if sequence data is loaded. 123 if not self.relax.data.res.has_key(self.run): 124 raise RelaxNoSequenceError, self.run 125 126 # Function type. 127 self.function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 128 129 # Minimisation parameter. 130 if self.relax.generic.minimise.return_data_name(param): 131 # Minimisation statistic flag. 132 min_stat = 1 133 134 # Specific value and error returning function. 135 return_value = self.relax.generic.minimise.return_value 136 137 # Specific set function. 138 set = self.relax.generic.minimise.set 139 140 # Normal parameter. 141 else: 142 # Minimisation statistic flag. 143 min_stat = 0 144 145 # Specific value and error returning function. 146 return_value = self.relax.specific_setup.setup('return_value', self.function_type) 147 148 # Specific set function. 149 set = self.relax.specific_setup.setup('set', self.function_type) 150 151 # Test data corresponding to param already exists. 152 for i in xrange(len(self.relax.data.res[self.run])): 153 # Skip unselected residues. 154 if not self.relax.data.res[self.run][i].select: 155 continue 156 157 # Get the value and error. 158 value, error = return_value(self.run, i, self.param) 159 160 # Data exists. 161 if value != None or error != None: 162 raise RelaxValueError, (self.param, self.run) 163 164 # Extract the data from the file. 165 file_data = self.relax.IO.extract_data(file) 166 167 # Count the number of header lines. 168 header_lines = 0 169 for i in xrange(len(file_data)): 170 try: 171 int(file_data[i][num_col]) 172 except: 173 header_lines = header_lines + 1 174 else: 175 break 176 177 # Remove the header. 178 file_data = file_data[header_lines:] 179 180 # Strip the data. 181 file_data = self.relax.IO.strip(file_data) 182 183 # Do nothing if the file does not exist. 184 if not file_data: 185 raise RelaxFileEmptyError 186 187 # Test the validity of the data. 188 for i in xrange(len(file_data)): 189 # Skip missing data. 190 if len(file_data[i]) <= data_col or len(file_data[i]) <= error_col: 191 continue 192 193 try: 194 # Number column. 195 int(file_data[i][num_col]) 196 197 # Value column. 198 if file_data[i][data_col] != 'None': 199 float(file_data[i][data_col]) 200 201 # Error column. 202 if error_col != None and file_data[i][error_col] != 'None': 203 float(file_data[i][error_col]) 204 205 except ValueError: 206 if error_col != None: 207 if name_col != None: 208 raise RelaxError, "The data is invalid (num=" + file_data[i][num_col] + ", name=" + file_data[i][name_col] + ", data=" + file_data[i][data_col] + ", error=" + file_data[i][error_col] + ")." 209 else: 210 raise RelaxError, "The data is invalid (num=" + file_data[i][num_col] + ", data=" + file_data[i][data_col] + ", error=" + file_data[i][error_col] + ")." 211 else: 212 if name_col != None: 213 raise RelaxError, "The data is invalid (num=" + file_data[i][num_col] + ", name=" + file_data[i][name_col] + ", data=" + file_data[i][data_col] + ")." 214 else: 215 raise RelaxError, "The data is invalid (num=" + file_data[i][num_col] + ", data=" + file_data[i][data_col] + ")." 216 217 # Loop over the data. 218 for i in xrange(len(file_data)): 219 # Skip missing data. 220 if len(file_data[i]) <= data_col or len(file_data[i]) <= error_col: 221 continue 222 223 # Residue number. 224 res_num = int(file_data[i][num_col]) 225 226 # Residue name. 227 if name_col == None: 228 res_name = None 229 else: 230 res_name = file_data[i][name_col] 231 232 # Value. 233 if file_data[i][data_col] != 'None': 234 value = float(file_data[i][data_col]) 235 else: 236 value = None 237 238 # Error. 239 if error_col != None and file_data[i][error_col] != 'None': 240 error = float(file_data[i][error_col]) 241 else: 242 error = None 243 244 # Find the index of self.relax.data.res[self.run] which corresponds to the relaxation data set i. 245 index = None 246 for j in xrange(len(self.relax.data.res[self.run])): 247 if self.relax.data.res[self.run][j].num == res_num and (res_name == None or self.relax.data.res[self.run][j].name == res_name): 248 index = j 249 break 250 if index == None: 251 raise RelaxNoResError, (res_num, res_name) 252 253 # Set the value. 254 set(run=run, value=value, error=error, param=self.param, scaling=scaling, index=index) 255 256 # Reset the residue specific minimisation statistics. 257 if not min_stat: 258 self.relax.generic.minimise.reset_min_stats(self.run, index) 259 260 # Reset the global minimisation statistics. 261 if not min_stat: 262 self.relax.generic.minimise.reset_min_stats(self.run)

263 264

265 - def set(self, run=None, value=None, param=None, res_num=None, res_name=None, force=0):

266 """Function for setting residue specific data values.""" 267 268 # Arguments 269 self.run = run 270 self.value = value 271 self.param = param 272 self.res_num = res_num 273 self.res_name = res_name 274 self.force = force 275 276 # Test if the run exists. 277 if not self.run in self.relax.data.run_names: 278 raise RelaxNoRunError, self.run 279 280 # Function type. 281 self.function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 282 283 # Specific functions. 284 self.return_data_name = self.relax.specific_setup.setup('return_data_name', self.function_type) 285 return_value = self.relax.specific_setup.setup('return_value', self.function_type) 286 set = self.relax.specific_setup.setup('set', self.function_type) 287 288 # Sort the parameters and their values. 289 self.sort_params() 290 291 292 # Diffusion tensor parameters. 293 ############################## 294 295 if self.diff_params: 296 # Set the diffusion parameters. 297 self.relax.generic.diffusion_tensor.set(run=self.run, value=self.diff_values, param=self.diff_params) 298 299 300 # Residue specific parameters. 301 ############################## 302 303 if self.res_params: 304 # Test if the sequence data is loaded. 305 if not self.relax.data.res.has_key(self.run): 306 raise RelaxNoSequenceError, self.run 307 308 # Test if the residue number is a valid regular expression. 309 if type(self.res_num) == str: 310 try: 311 compile(self.res_num) 312 except: 313 raise RelaxRegExpError, ('residue number', self.res_num) 314 315 # Test if the residue name is a valid regular expression. 316 if self.res_name: 317 try: 318 compile(self.res_name) 319 except: 320 raise RelaxRegExpError, ('residue name', self.res_name) 321 322 # Test if parameter value already exists. 323 if not self.force: 324 # Loop over the residues. 325 for i in xrange(len(self.relax.data.res[self.run])): 326 # Skip unselected residues. 327 if not self.relax.data.res[self.run][i].select: 328 continue 329 330 # If 'res_num' is not None, skip the residue if there is no match. 331 if type(self.res_num) == int and not self.relax.data.res[self.run][i].num == self.res_num: 332 continue 333 elif type(self.res_num) == str and not match(self.res_num, `self.relax.data.res[self.run][i].num`): 334 continue 335 336 # If 'res_name' is not None, skip the residue if there is no match. 337 if self.res_name != None and not match(self.res_name, self.relax.data.res[self.run][i].name): 338 continue 339 340 # Loop over the parameters. 341 for param in self.res_params: 342 if param: 343 # Get the value and error. 344 temp_value, temp_error = return_value(self.run, i, param) 345 346 # Data exists. 347 if temp_value != None or temp_error != None: 348 raise RelaxValueError, (param, self.run) 349 350 # Loop over the sequence. 351 for i in xrange(len(self.relax.data.res[self.run])): 352 # Skip unselected residues. 353 if not self.relax.data.res[self.run][i].select: 354 continue 355 356 # If 'res_num' is not None, skip the residue if there is no match. 357 if type(self.res_num) == int and not self.relax.data.res[self.run][i].num == self.res_num: 358 continue 359 elif type(self.res_num) == str and not match(self.res_num, `self.relax.data.res[self.run][i].num`): 360 continue 361 362 # If 'res_name' is not None, skip the residue if there is no match. 363 if self.res_name != None and not match(self.res_name, self.relax.data.res[self.run][i].name): 364 continue 365 366 # Go to the specific code. 367 for j in xrange(len(self.res_params)): 368 set(run=self.run, value=self.res_values[j], error=None, param=self.res_params[j], index=i) 369 370 371 # Reset the minimisation statistics. 372 #################################### 373 374 # Reset the global minimisation statistics. 375 self.relax.generic.minimise.reset_min_stats(self.run) 376 377 # Reset the sequence specific minimisation statistics. 378 if self.relax.data.res.has_key(self.run): 379 for i in xrange(len(self.relax.data.res[self.run])): 380 self.relax.generic.minimise.reset_min_stats(self.run, i)

381 382

383 - def sort_params(self):

384 """Function for sorting the parameters and their values.""" 385 386 # Initialise. 387 self.diff_params = [] 388 self.diff_values = [] 389 self.res_params = [] 390 self.res_values = [] 391 392 # Separate the residue specific parameters from the diffusion tensor parameters. 393 if self.param: 394 # Single parameter. 395 if type(self.param) == str: 396 # Get the diffusion tensor parameter name. 397 diff_name = self.relax.generic.diffusion_tensor.return_data_name(self.param) 398 399 # The parameter is a diffusion parameter. 400 if diff_name: 401 # List of values. 402 if type(self.value) == list or type(self.value) == ArrayType: 403 # Parameter name. 404 for i in xrange(len(self.value)): 405 self.diff_params.append(diff_name) 406 407 # Parameter value. 408 self.diff_values = self.value 409 410 # Single value. 411 else: 412 # Parameter name. 413 self.diff_params.append(self.param) 414 415 # Parameter value. 416 self.diff_values.append(self.value) 417 418 # The parameter is not a diffusion parameter. 419 elif self.return_data_name(self.param): 420 # List of values. 421 if type(self.value) == list or type(self.value) == ArrayType: 422 # Parameter name. 423 for i in xrange(len(self.value)): 424 self.res_params.append(self.param) 425 426 # Parameter value. 427 self.res_values = self.value 428 429 # Single value. 430 else: 431 # Parameter name. 432 self.res_params.append(self.param) 433 434 # Parameter value. 435 self.res_values.append(self.value) 436 437 # Unknown parameter 438 else: 439 raise RelaxUnknownParamError, self.param 440 441 # Multiple parameters. 442 elif type(self.param) == list: 443 # Loop over all parameters. 444 for i in xrange(len(self.param)): 445 # Get the diffusion tensor parameter name. 446 diff_name = self.relax.generic.diffusion_tensor.return_data_name(self.param[i]) 447 448 # The parameter is a diffusion parameter. 449 if diff_name: 450 # Parameter name. 451 self.diff_params.append(diff_name) 452 453 # Parameter value. 454 if type(self.value) == list or type(self.value) == ArrayType: 455 self.diff_values.append(self.value[i]) 456 else: 457 self.diff_values.append(self.value) 458 459 # The parameter is not a diffusion parameter. 460 elif self.return_data_name(self.param[i]): 461 # Parameter name. 462 self.res_params.append(self.param[i]) 463 464 # Parameter value. 465 if type(self.value) == list or type(self.value) == ArrayType: 466 self.res_values.append(self.value[i]) 467 else: 468 self.res_values.append(self.value) 469 470 # Unknown parameter 471 else: 472 raise RelaxUnknownParamError, self.param[i] 473 474 475 # All other parameters. 476 else: 477 # No parameter or a single parameter. 478 if self.param == None or type(self.param) == str: 479 # List of values. 480 if type(self.value) == list or type(self.value) == ArrayType: 481 # Parameter name. 482 for i in xrange(len(self.value)): 483 self.res_params.append(self.param) 484 485 # Parameter value. 486 self.res_values = self.value 487 488 # Single value. 489 else: 490 # Parameter name. 491 self.res_params.append(self.param) 492 493 # Parameter value. 494 self.res_values.append(self.value) 495 496 # Multiple parameters. 497 elif type(self.param) == list: 498 # Loop over all parameters. 499 for i in xrange(len(self.param)): 500 # Parameter name. 501 self.res_params.append(self.param[i]) 502 503 # Parameter value. 504 if type(self.value) == list or type(self.value) == ArrayType: 505 self.res_values.append(self.value[i]) 506 else: 507 self.res_values.append(self.value) 508 509 # Debugging. 510 if len(self.diff_params) != len(self.diff_values) or len(self.res_params) != len(self.res_values): 511 print "Diff params: " + `self.diff_params` 512 print "Diff values: " + `self.diff_values` 513 print "Res params: " + `self.res_params` 514 print "Res values: " + `self.res_values` 515 raise RelaxError, "Bug in the code."

516 517

518 - def write(self, run=None, param=None, file=None, dir=None, force=0, return_value=None):

519 """Function for writing data to a file.""" 520 521 # Arguments. 522 self.run = run 523 self.param = param 524 525 # Test if the run exists. 526 if not self.run in self.relax.data.run_names: 527 raise RelaxNoRunError, self.run 528 529 # Test if the sequence data is loaded. 530 if not self.relax.data.res.has_key(self.run): 531 raise RelaxNoSequenceError, self.run 532 533 # Open the file for writing. 534 file = self.relax.IO.open_write_file(file, dir, force) 535 536 # Write the data. 537 self.write_data(run=run, param=param, file=file, return_value=return_value) 538 539 # Close the file. 540 file.close()

541 542

543 - def write_data(self, run=None, param=None, file=None, return_value=None):

544 """Function for writing data.""" 545 546 # Get the value and error returning function if required. 547 if not return_value: 548 # Function type. 549 self.function_type = self.relax.data.run_types[self.relax.data.run_names.index(run)] 550 551 # Specific value and error returning function. 552 return_value = self.relax.specific_setup.setup('return_value', self.function_type) 553 554 # Write a header line. 555 file.write("%-5s%-6s%-30s%-30s\n" % ('Num', 'Name', 'Value', 'Error')) 556 557 # Loop over the sequence. 558 for i in xrange(len(self.relax.data.res[run])): 559 # Remap the data structure 'self.relax.data.res[run][i]'. 560 data = self.relax.data.res[run][i] 561 562 # Get the value and error. 563 value, error = return_value(run, i, param) 564 565 # Write the data. 566 file.write("%-5i%-6s%-30s%-30s\n" % (data.num, data.name, `value`, `error`))

Source Code for Module generic_fns.value