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(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 # Get the value and error. 154 value, error = return_value(self.run, i, self.param) 155 156 # Data exists. 157 if value != None or error != None: 158 raise RelaxValueError, (self.param, self.run) 159 160 # Extract the data from the file. 161 file_data = self.relax.IO.extract_data(file) 162 163 # Count the number of header lines. 164 header_lines = 0 165 for i in xrange(len(file_data)): 166 try: 167 int(file_data[i][num_col]) 168 except: 169 header_lines = header_lines + 1 170 else: 171 break 172 173 # Remove the header. 174 file_data = file_data[header_lines:] 175 176 # Strip the data. 177 file_data = self.relax.IO.strip(file_data) 178 179 # Do nothing if the file does not exist. 180 if not file_data: 181 raise RelaxFileEmptyError 182 183 # Test the validity of the data. 184 for i in xrange(len(file_data)): 185 try: 186 # Number column. 187 int(file_data[i][num_col]) 188 189 # Value column. 190 if file_data[i][data_col] != 'None': 191 float(file_data[i][data_col]) 192 193 # Error column. 194 if error_col != None and file_data[i][error_col] != 'None': 195 float(file_data[i][error_col]) 196 197 except ValueError: 198 if error_col != None: 199 if name_col != None: 200 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] + ")." 201 else: 202 raise RelaxError, "The data is invalid (num=" + file_data[i][num_col] + ", data=" + file_data[i][data_col] + ", error=" + file_data[i][error_col] + ")." 203 else: 204 if name_col != None: 205 raise RelaxError, "The data is invalid (num=" + file_data[i][num_col] + ", name=" + file_data[i][name_col] + ", data=" + file_data[i][data_col] + ")." 206 else: 207 raise RelaxError, "The data is invalid (num=" + file_data[i][num_col] + ", data=" + file_data[i][data_col] + ")." 208 209 # Loop over the data. 210 for i in xrange(len(file_data)): 211 # Residue number. 212 res_num = int(file_data[i][num_col]) 213 214 # Residue name. 215 if name_col == None: 216 res_name = None 217 else: 218 res_name = file_data[i][name_col] 219 220 # Value. 221 if file_data[i][data_col] != 'None': 222 value = float(file_data[i][data_col]) 223 else: 224 value = None 225 226 # Error. 227 if error_col != None and file_data[i][error_col] != 'None': 228 error = float(file_data[i][error_col]) 229 else: 230 error = None 231 232 # Find the index of self.relax.data.res[self.run] which corresponds to the relaxation data set i. 233 index = None 234 for j in xrange(len(self.relax.data.res[self.run])): 235 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): 236 index = j 237 break 238 if index == None: 239 raise RelaxNoResError, (res_num, res_name) 240 241 # Set the value. 242 set(run=run, value=value, error=error, param=self.param, scaling=scaling, index=i) 243 244 # Reset the residue specific minimisation statistics. 245 if not min_stat: 246 self.relax.generic.minimise.reset_min_stats(self.run, i) 247 248 # Reset the global minimisation statistics. 249 if not min_stat: 250 self.relax.generic.minimise.reset_min_stats(self.run)

251 252

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

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

361 362

363 - def sort_params(self, value, param):

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

496 497

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

499 """Function for writing data to a file.""" 500 501 # Arguments. 502 self.run = run 503 self.param = param 504 505 # Test if the run exists. 506 if not self.run in self.relax.data.run_names: 507 raise RelaxNoRunError, self.run 508 509 # Test if the sequence data is loaded. 510 if not self.relax.data.res.has_key(self.run): 511 raise RelaxNoSequenceError, self.run 512 513 # Open the file for writing. 514 file = self.relax.IO.open_write_file(file, dir, force) 515 516 # Write the data. 517 self.write_data(file) 518 519 # Close the file. 520 file.close()

521 522

523 - def write_data(self, file, return_value=None):

524 """Function for writing data.""" 525 526 # Get the value and error returning function if required. 527 if not return_value: 528 # Function type. 529 self.function_type = self.relax.data.run_types[self.relax.data.run_names.index(self.run)] 530 531 # Specific value and error returning function. 532 return_value = self.relax.specific_setup.setup('return_value', self.function_type) 533 534 # Write a header line. 535 file.write("%-5s%-6s%-30s%-30s\n" % ('Num', 'Name', 'Value', 'Error')) 536 537 # Loop over the sequence. 538 for i in xrange(len(self.relax.data.res[self.run])): 539 # Remap the data structure 'self.relax.data.res[self.run][i]'. 540 data = self.relax.data.res[self.run][i] 541 542 # Get the value and error. 543 value, error = return_value(self.run, i, self.param) 544 545 # Write the data. 546 file.write("%-5i%-6s%-30s%-30s\n" % (data.num, data.name, `value`, `error`))

Source Code for Module generic_fns.value