maths_fns.mf

42 - def __init__(self, init_params=None, model_type=None, diff_type=None, diff_params=None, scaling_matrix=None, num_spins=None, equations=None, param_types=None, param_values=None, relax_data=None, errors=None, bond_length=None, csa=None, num_frq=0, frq=None, num_ri=None, remap_table=None, noe_r1_table=None, ri_labels=None, gx=0, gh=0, h_bar=0, mu0=0, num_params=None, vectors=None):

43 """The model-free minimisation class. 44 45 This class should be initialised before every calculation. 46 47 48 Arguments 49 ========= 50 51 equation: The model-free equation string which should be either 'mf_orig' or 'mf_ext'. 52 53 param_types: An array of the parameter types used in minimisation. 54 55 relax_data: An array containing the experimental relaxation values. 56 57 errors: An array containing the experimental errors. 58 59 bond_length: The fixed bond length in meters. 60 61 csa: The fixed CSA value. 62 63 diff_type: The diffusion tensor string which should be either 'sphere', 'spheroid', or 64 'ellipsoid'. 65 66 diff_params: An array with the diffusion parameters. 67 68 scaling_matrix: A diagonal matrix of scaling factors. 69 70 71 72 Additional layer of equations to simplify the relaxation equations, gradients, and Hessians. 73 ============================================================================================ 74 75 The R1 and R2 equations are left alone, while the NOE is calculated from the R1 and 76 sigma_noe values. 77 78 79 The relaxation equations 80 ======================== 81 82 Data structure: data.ri 83 Dimension: 1D, (relaxation data) 84 Type: numpy, float64 85 Dependencies: data.ri_prime 86 Required by: data.chi2, data.dchi2, data.d2chi2 87 88 The equations are:: 89 90 R1() = R1'() 91 92 93 R2() = R2'() 94 95 gH sigma_noe() 96 NOE() = 1 + -- . ----------- 97 gN R1() 98 99 100 101 The relaxation gradients 102 ======================== 103 104 Data structure: data.dri 105 Dimension: 2D, (parameters, relaxation data) 106 Type: numpy array, float64 107 Dependencies: data.ri_prime, data.dri_prime 108 Required by: data.dchi2, data.d2chi2 109 110 The equations are:: 111 112 dR1() dR1'() 113 ------- = ------- 114 dthetaj dthetaj 115 116 117 dR2() dR2'() 118 ------- = ------- 119 dthetaj dthetaj 120 121 122 dNOE() gH 1 / dsigma_noe() dR1() \ 123 ------- = -- . ------- . | R1() . ------------ - sigma_noe() . ------- | 124 dthetaj gN R1()**2 \ dthetaj dthetaj / 125 126 127 128 The relaxation Hessians 129 ======================= 130 131 Data structure: data.d2ri 132 Dimension: 3D, (parameters, parameters, relaxation data) 133 Type: numpy array, float64 134 Dependencies: data.ri_prime, data.dri_prime, data.d2ri_prime 135 Required by: data.d2chi2 136 137 The equations are:: 138 139 d2R1() d2R1'() 140 --------------- = --------------- 141 dthetai.dthetaj dthetai.dthetaj 142 143 144 d2R2() d2R2'() 145 --------------- = --------------- 146 dthetai.dthetaj dthetai.dthetaj 147 148 149 d2NOE() gH 1 / / dR1() dR1() d2R1() \ 150 --------------- = -- . ------- . | sigma_noe() . | 2 . ------- . ------- - R1() . --------------- | 151 dthetai.dthetaj gN R1()**3 \ \ dthetai dthetaj dthetai.dthetaj / 152 153 / dsigma_noe() dR1() dR1() dsigma_noe() d2sigma_noe() \ \ 154 - R1() . | ------------ . ------- + ------- . ------------ - R1() . --------------- | | 155 \ dthetai dthetaj dthetai dthetaj dthetai.dthetaj / / 156 157 158 159 The chi-sqared equation 160 ======================= 161 162 The equation is:: 163 _n_ 164 \ (Ri - Ri()) ** 2 165 chi2 = > ---------------- 166 /__ sigma_i ** 2 167 i=1 168 169 where: 170 - Ri are the values of the measured relaxation data set. 171 - Ri() are the values of the back calculated relaxation data set. 172 - sigma_i are the values of the error set. 173 174 175 The chi-sqared gradient 176 ======================= 177 178 The equation is:: 179 _n_ 180 dchi2 \ / Ri - Ri() dRi() \ 181 ------- = -2 > | ---------- . ------- | 182 dthetaj /__ \ sigma_i**2 dthetaj / 183 i=1 184 185 where: 186 - Ri are the values of the measured relaxation data set. 187 - Ri() are the values of the back calculated relaxation data set. 188 - sigma_i are the values of the error set. 189 190 191 The chi-sqared Hessian 192 ====================== 193 194 The equation is:: 195 _n_ 196 d2chi2 \ 1 / dRi() dRi() d2Ri() \ 197 --------------- = 2 > ---------- | ------- . ------- - (Ri - Ri()) . --------------- | 198 dthetaj.dthetak /__ sigma_i**2 \ dthetaj dthetak dthetaj.dthetak / 199 i=1 200 201 where: 202 - Ri are the values of the measured relaxation data set. 203 - Ri() are the values of the back calculated relaxation data set. 204 - sigma_i are the values of the error set. 205 """ 206 207 # Arguments. 208 self.model_type = model_type 209 self.total_num_params = len(init_params) 210 self.scaling_matrix = scaling_matrix 211 self.num_spins = num_spins 212 self.params = 1.0 * init_params 213 214 # Data structures for tests set to some random array (in this case all pi). 215 self.func_test = pi * ones(self.total_num_params, float64) 216 self.grad_test = pi * ones(self.total_num_params, float64) 217 self.hess_test = pi * ones(self.total_num_params, float64) 218 219 # Initialise the data class for storing diffusion tensor data. 220 self.diff_data = Data() 221 self.diff_data.type = diff_type 222 self.diff_data.params = diff_params 223 self.init_diff_data(self.diff_data) 224 225 # Total number of ri. 226 self.total_num_ri = 0 227 228 # Set the function for packaging diffusion tensor parameters. 229 if self.diff_data.type == 'sphere': 230 self.param_index = 1 231 self.diff_end_index = 1 232 elif self.diff_data.type == 'spheroid': 233 self.param_index = 4 234 self.diff_end_index = 4 235 elif self.diff_data.type == 'ellipsoid': 236 self.param_index = 6 237 self.diff_end_index = 6 238 if self.model_type != 'all': 239 self.param_index = 0 240 241 # Create the data array used to store data. 242 self.data = [] 243 for i in xrange(self.num_spins): 244 # Total number of ri. 245 self.total_num_ri = self.total_num_ri + num_ri[i] 246 247 # The ratio of gyromagnetic ratios. 248 g_ratio = gh[i] / gx[i] 249 250 # Append the class instance Data to the data array. 251 self.data.append(Data()) 252 253 # Number of indices. 254 self.data[i].num_indices = self.diff_data.num_indices 255 256 # Calculate the five frequencies per field strength which cause R1, R2, and NOE relaxation. 257 self.data[i].frq_list = zeros((num_frq[i], 5), float64) 258 self.data[i].frq_list_ext = zeros((num_frq[i], 5, self.diff_data.num_indices), float64) 259 self.data[i].frq_sqrd_list_ext = zeros((num_frq[i], 5, self.diff_data.num_indices), float64) 260 for j in xrange(num_frq[i]): 261 frqH = 2.0 * pi * frq[i][j] 262 frqX = frqH / g_ratio 263 self.data[i].frq_list[j, 1] = frqX 264 self.data[i].frq_list[j, 2] = frqH - frqX 265 self.data[i].frq_list[j, 3] = frqH 266 self.data[i].frq_list[j, 4] = frqH + frqX 267 self.data[i].frq_sqrd_list = self.data[i].frq_list ** 2 268 for j in xrange(self.diff_data.num_indices): 269 self.data[i].frq_list_ext[:,:, j] = self.data[i].frq_list 270 self.data[i].frq_sqrd_list_ext[:,:, j] = self.data[i].frq_sqrd_list 271 272 # Store supplied data in self.data 273 self.data[i].gh = gh[i] 274 self.data[i].gx = gx[i] 275 self.data[i].g_ratio = g_ratio 276 self.data[i].h_bar = h_bar 277 self.data[i].mu0 = mu0 278 self.data[i].equations = equations[i] 279 self.data[i].param_types = param_types[i] 280 self.data[i].relax_data = relax_data[i] 281 self.data[i].errors = errors[i] 282 self.data[i].bond_length = bond_length[i] 283 self.data[i].csa = csa[i] 284 self.data[i].num_ri = num_ri[i] 285 self.data[i].num_frq = num_frq[i] 286 self.data[i].frq = frq[i] 287 self.data[i].remap_table = remap_table[i] 288 self.data[i].noe_r1_table = noe_r1_table[i] 289 self.data[i].ri_labels = ri_labels[i] 290 self.data[i].num_params = num_params[i] 291 self.data[i].xh_unit_vector = vectors[i] 292 293 # Parameter values for minimising solely the diffusion tensor parameters. 294 if self.model_type == 'diff': 295 self.data[i].param_values = param_values[i] 296 297 # Indices for constructing the global generic model-free gradient and Hessian kite. 298 if i == 0: 299 self.data[i].start_index = self.diff_data.num_params 300 else: 301 self.data[i].start_index = self.data[i-1].end_index 302 self.data[i].end_index = self.data[i].start_index + self.data[i].num_params 303 304 # Total number of parameters. 305 if self.model_type == 'mf' or self.model_type == 'local_tm': 306 self.data[i].total_num_params = self.data[i].num_params 307 elif self.model_type == 'diff': 308 self.data[i].total_num_params = self.diff_data.num_params 309 else: 310 self.data[i].total_num_params = self.data[i].num_params + self.diff_data.num_params 311 312 # Initialise the residue specific data. 313 self.init_res_data(self.data[i], self.diff_data) 314 315 # Setup the residue specific equations. 316 if not self.setup_equations(self.data[i]): 317 raise RelaxError("The model-free equations could not be setup.") 318 319 # Diffusion tensor parameters. 320 if self.model_type == 'local_tm': 321 self.diff_data.params = self.params[0:1] 322 elif self.model_type == 'diff' or self.model_type == 'all': 323 self.diff_data.params = self.params[0:self.diff_end_index] 324 325 # Calculate the correlation times ti. 326 self.diff_data.calc_ti(self.data[i], self.diff_data) 327 328 # ti spectral density components. 329 self.data[i].w_ti_sqrd = self.data[i].frq_sqrd_list_ext * self.data[i].ti ** 2 330 self.data[i].fact_ti = 1.0 / (1.0 + self.data[i].w_ti_sqrd) 331 332 # Initialise the R1 data class. This is used only if an NOE data set is collected but the R1 data of the same frequency has not. 333 missing_r1 = 0 334 for j in xrange(self.data[i].num_ri): 335 if self.data[i].ri_labels[j] == 'NOE' and self.data[i].noe_r1_table[j] == None: 336 missing_r1 = 1 337 if missing_r1: 338 self.init_res_r1_data(self.data[i]) 339 340 # Scaling initialisation. 341 if self.scaling_matrix != None: 342 self.scaling_flag = 1 343 else: 344 self.scaling_flag = 0 345 346 # Initialise the total chi2 value, gradient, and Hessian data structures. 347 self.total_chi2 = 0.0 348 self.total_dchi2 = zeros((self.total_num_params), float64) 349 self.total_d2chi2 = zeros((self.total_num_params, self.total_num_params), float64) 350 351 # Initialise the total ri gradient data structure (for Levenberg-Marquardt minimisation). 352 self.total_dri = zeros((self.total_num_params, self.total_num_ri), float64) 353 354 # Set the functions self.func, self.dfunc, and self.d2func. 355 ########################################################### 356 357 # Functions for minimising model-free parameters for a single residue. 358 if self.model_type == 'mf': 359 self.func = self.func_mf 360 self.dfunc = self.dfunc_mf 361 self.d2func = self.d2func_mf 362 363 # Functions for minimising model-free parameters for a single residue with a local tm. 364 elif self.model_type == 'local_tm': 365 self.func = self.func_local_tm 366 self.dfunc = self.dfunc_local_tm 367 self.d2func = self.d2func_local_tm 368 369 # Functions for minimising diffusion tensor parameters with all model-free parameters fixed. 370 elif self.model_type == 'diff': 371 self.func = self.func_diff 372 self.dfunc = self.dfunc_diff 373 self.d2func = self.d2func_diff 374 375 # Functions for minimising diffusion tensor parameters together with all model-free parameters. 376 elif self.model_type == 'all': 377 self.func = self.func_all 378 self.dfunc = self.dfunc_all 379 self.d2func = self.d2func_all

380 381

382 - def func_mf(self, params):

383 """Function for calculating the chi-squared value. 384 385 Used in the minimisation of model-free parameters for a single residue. 386 """ 387 388 # Store the parameter values in self.func_test for testing. 389 self.func_test = params * 1.0 390 391 # Set self.data[0] to data. 392 data = self.data[0] 393 394 # Scaling. 395 if self.scaling_flag: 396 params = dot(params, self.scaling_matrix) 397 398 # Direction cosine calculations. 399 if self.diff_data.calc_di: 400 self.diff_data.calc_di(data, self.diff_data) 401 402 # Diffusion tensor weight calculations. 403 self.diff_data.calc_ci(data, self.diff_data) 404 405 # Diffusion tensor correlation times. 406 self.diff_data.calc_ti(data, self.diff_data) 407 408 # Calculate the components of the spectral densities. 409 if data.calc_jw_comps: 410 data.calc_jw_comps(data, params) 411 412 # Calculate the spectral density values. 413 data.jw = data.calc_jw(data, params) 414 415 # Calculate the relaxation formula components. 416 data.create_ri_comps(data, params) 417 418 # Calculate the R1, R2, and sigma_noe values. 419 data.ri_prime = data.create_ri_prime(data) 420 421 # Calculate the NOE values. 422 data.ri = data.ri_prime * 1.0 423 for m in xrange(data.num_ri): 424 if data.create_ri[m]: 425 data.create_ri[m](data, m, data.remap_table[m], data.get_r1, params) 426 427 # Calculate the chi-squared value. 428 data.chi2 = chi2(data.relax_data, data.ri, data.errors) 429 430 return data.chi2

431 432

433 - def func_local_tm(self, params):

434 """Function for calculating the chi-squared value. 435 436 Used in the minimisation of model-free parameters for a single residue with a local tm. 437 """ 438 439 # Store the parameter values in self.func_test for testing. 440 self.func_test = params * 1.0 441 442 # Set self.data[0] to data. 443 data = self.data[0] 444 445 # Scaling. 446 if self.scaling_flag: 447 params = dot(params, self.scaling_matrix) 448 449 # Diffusion tensor parameters. 450 self.diff_data.params = params[0:1] 451 452 # Diffusion tensor weight calculations. 453 self.diff_data.calc_ci(data, self.diff_data) 454 455 # Diffusion tensor correlation times. 456 self.diff_data.calc_ti(data, self.diff_data) 457 458 # ti spectral density components. 459 data.w_ti_sqrd = data.frq_sqrd_list_ext * data.ti ** 2 460 data.fact_ti = 1.0 / (1.0 + data.w_ti_sqrd) 461 462 # Calculate the components of the spectral densities. 463 if data.calc_jw_comps: 464 data.calc_jw_comps(data, params) 465 466 # Calculate the spectral density values. 467 data.jw = data.calc_jw(data, params) 468 469 # Calculate the relaxation formula components. 470 data.create_ri_comps(data, params) 471 472 # Calculate the R1, R2, and sigma_noe values. 473 data.ri_prime = data.create_ri_prime(data) 474 475 # Calculate the NOE values. 476 data.ri = data.ri_prime * 1.0 477 for m in xrange(data.num_ri): 478 if data.create_ri[m]: 479 data.create_ri[m](data, m, data.remap_table[m], data.get_r1, params) 480 481 # Calculate the chi-squared value. 482 data.chi2 = chi2(data.relax_data, data.ri, data.errors) 483 484 return data.chi2

485 486

487 - def func_diff(self, params):

488 """Function for calculating the chi-squared value. 489 490 Used in the minimisation of diffusion tensor parameters with all model-free parameters 491 fixed. 492 """ 493 494 # Store the parameter values in self.func_test for testing. 495 self.func_test = params * 1.0 496 497 # Scaling. 498 if self.scaling_flag: 499 params = dot(params, self.scaling_matrix) 500 501 # Diffusion tensor parameters. 502 self.diff_data.params = params[0:self.diff_end_index] 503 504 # Set the total chi2 to zero. 505 self.total_chi2 = 0.0 506 507 # Loop over the residues. 508 for i in xrange(self.num_spins): 509 # Set self.data[i] to data. 510 data = self.data[i] 511 512 # Direction cosine calculations. 513 if self.diff_data.calc_di: 514 self.diff_data.calc_di(data, self.diff_data) 515 516 # Diffusion tensor weight calculations. 517 self.diff_data.calc_ci(data, self.diff_data) 518 519 # Diffusion tensor correlation times. 520 self.diff_data.calc_ti(data, self.diff_data) 521 522 # ti spectral density components. 523 data.w_ti_sqrd = data.frq_sqrd_list_ext * data.ti ** 2 524 data.fact_ti = 1.0 / (1.0 + data.w_ti_sqrd) 525 526 # Calculate the components of the spectral densities. 527 if data.calc_jw_comps: 528 data.calc_jw_comps(data, data.param_values) 529 530 # Calculate the spectral density values. 531 data.jw = data.calc_jw(data, data.param_values) 532 533 # Calculate the relaxation formula components. 534 data.create_ri_comps(data, data.param_values) 535 536 # Calculate the R1, R2, and sigma_noe values. 537 data.ri_prime = data.create_ri_prime(data) 538 539 # Calculate the NOE values. 540 data.ri = data.ri_prime * 1.0 541 for m in xrange(data.num_ri): 542 if data.create_ri[m]: 543 data.create_ri[m](data, m, data.remap_table[m], data.get_r1, data.param_values) 544 545 # Calculate the chi-squared value. 546 data.chi2 = chi2(data.relax_data, data.ri, data.errors) 547 548 # Add the residue specific chi2 to the total chi2. 549 self.total_chi2 = self.total_chi2 + data.chi2 550 551 return self.total_chi2

552 553

554 - def func_all(self, params):

555 """Function for calculating the chi-squared value. 556 557 Used in the minimisation of diffusion tensor parameters together with all model-free 558 parameters. 559 """ 560 561 # Store the parameter values in self.func_test for testing. 562 self.func_test = params * 1.0 563 564 # Scaling. 565 if self.scaling_flag: 566 params = dot(params, self.scaling_matrix) 567 568 # Diffusion tensor parameters. 569 self.diff_data.params = params[0:self.diff_end_index] 570 571 # Set the total chi2 to zero. 572 self.total_chi2 = 0.0 573 574 # Loop over the residues. 575 for i in xrange(self.num_spins): 576 # Set self.data[i] to data. 577 data = self.data[i] 578 579 # Direction cosine calculations. 580 if self.diff_data.calc_di: 581 self.diff_data.calc_di(data, self.diff_data) 582 583 # Diffusion tensor weight calculations. 584 self.diff_data.calc_ci(data, self.diff_data) 585 586 # Diffusion tensor correlation times. 587 self.diff_data.calc_ti(data, self.diff_data) 588 589 # ti spectral density components. 590 data.w_ti_sqrd = data.frq_sqrd_list_ext * data.ti ** 2 591 data.fact_ti = 1.0 / (1.0 + data.w_ti_sqrd) 592 593 # Calculate the components of the spectral densities. 594 if data.calc_jw_comps: 595 data.calc_jw_comps(data, params) 596 597 # Calculate the spectral density values. 598 data.jw = data.calc_jw(data, params) 599 600 # Calculate the relaxation formula components. 601 data.create_ri_comps(data, params) 602 603 # Calculate the R1, R2, and sigma_noe values. 604 data.ri_prime = data.create_ri_prime(data) 605 606 # Calculate the NOE values. 607 data.ri = data.ri_prime * 1.0 608 for m in xrange(data.num_ri): 609 if data.create_ri[m]: 610 data.create_ri[m](data, m, data.remap_table[m], data.get_r1, params) 611 612 # Calculate the chi-squared value. 613 data.chi2 = chi2(data.relax_data, data.ri, data.errors) 614 615 # Add the residue specific chi2 to the total chi2. 616 self.total_chi2 = self.total_chi2 + data.chi2 617 618 return self.total_chi2

619 620

621 - def dfunc_mf(self, params):

622 """Function for calculating the chi-squared gradient. 623 624 Used in the minimisation of model-free parameters for a single residue. 625 """ 626 627 # Test if the function has already been called, otherwise run self.func. 628 if sum(params == self.func_test) != self.total_num_params: 629 self.func(params) 630 631 # Store the parameter values in self.grad_test for testing. 632 self.grad_test = params * 1.0 633 634 # Set self.data[0] to data. 635 data = self.data[0] 636 637 # Scaling. 638 if self.scaling_flag: 639 params = dot(params, self.scaling_matrix) 640 641 # Calculate the spectral density gradient components. 642 if data.calc_djw_comps: 643 data.calc_djw_comps(data, params) 644 645 # Loop over the gradient. 646 for j in xrange(data.total_num_params): 647 # Calculate the spectral density gradients. 648 if data.calc_djw[j]: 649 data.djw = data.calc_djw[j](data, params, j) 650 else: 651 data.djw = data.djw * 0.0 652 653 # Calculate the relaxation gradient components. 654 data.create_dri_comps(data, params) 655 656 # Calculate the R1, R2, and sigma_noe gradients. 657 data.dri_prime[j] = data.create_dri_prime[j](data) 658 659 # Loop over the relaxation values and modify the NOE gradients. 660 data.dri[j] = data.dri_prime[j] 661 for m in xrange(data.num_ri): 662 if data.create_dri[m]: 663 data.create_dri[m](data, m, data.remap_table[m], data.get_dr1, params, j) 664 665 # Calculate the chi-squared gradient. 666 data.dchi2[j] = dchi2_element(data.relax_data, data.ri, data.dri[j], data.errors) 667 668 # Diagonal scaling. 669 if self.scaling_flag: 670 data.dchi2 = dot(data.dchi2, self.scaling_matrix) 671 672 # Return a copy of the gradient. 673 return data.dchi2 * 1.0

674 675

676 - def dfunc_local_tm(self, params):

677 """Function for calculating the chi-squared gradient. 678 679 Used in the minimisation of model-free parameters for a single residue with a local tm. 680 """ 681 682 # Test if the function has already been called, otherwise run self.func. 683 if sum(params == self.func_test) != self.total_num_params: 684 self.func(params) 685 686 # Store the parameter values in self.grad_test for testing. 687 self.grad_test = params * 1.0 688 689 # Set self.data[0] to data. 690 data = self.data[0] 691 692 # Scaling. 693 if self.scaling_flag: 694 params = dot(params, self.scaling_matrix) 695 696 # Diffusion tensor parameters. 697 self.diff_data.params = params[0:1] 698 699 # Calculate the spectral density gradient components. 700 if data.calc_djw_comps: 701 data.calc_djw_comps(data, params) 702 703 # Diffusion tensor correlation times. 704 self.diff_data.calc_dti(data, self.diff_data) 705 706 # Loop over the gradient. 707 for j in xrange(data.total_num_params): 708 # Calculate the spectral density gradients. 709 if data.calc_djw[j]: 710 data.djw = data.calc_djw[j](data, params, j) 711 else: 712 data.djw = data.djw * 0.0 713 714 # Calculate the relaxation gradient components. 715 data.create_dri_comps(data, params) 716 717 # Calculate the R1, R2, and sigma_noe gradients. 718 data.dri_prime[j] = data.create_dri_prime[j](data) 719 720 # Loop over the relaxation values and modify the NOE gradients. 721 data.dri[j] = data.dri_prime[j] 722 for m in xrange(data.num_ri): 723 if data.create_dri[m]: 724 data.create_dri[m](data, m, data.remap_table[m], data.get_dr1, params, j) 725 726 # Calculate the chi-squared gradient. 727 data.dchi2[j] = dchi2_element(data.relax_data, data.ri, data.dri[j], data.errors) 728 729 # Diagonal scaling. 730 if self.scaling_flag: 731 data.dchi2 = dot(data.dchi2, self.scaling_matrix) 732 733 # Return a copy of the gradient. 734 return data.dchi2 * 1.0

735 736

737 - def dfunc_diff(self, params):

738 """Function for calculating the chi-squared gradient. 739 740 Used in the minimisation of diffusion tensor parameters with all model-free parameters 741 fixed. 742 """ 743 744 # Test if the function has already been called, otherwise run self.func. 745 if sum(params == self.func_test) != self.total_num_params: 746 self.func(params) 747 748 # Store the parameter values in self.grad_test for testing. 749 self.grad_test = params * 1.0 750 751 # Scaling. 752 if self.scaling_flag: 753 params = dot(params, self.scaling_matrix) 754 755 # Diffusion tensor parameters. 756 self.diff_data.params = params[0:self.diff_end_index] 757 758 # Set the total chi2 gradient to zero. 759 self.total_dchi2 = self.total_dchi2 * 0.0 760 761 # Loop over the residues. 762 for i in xrange(self.num_spins): 763 764 # Set self.data[i] to data. 765 data = self.data[i] 766 767 # Direction cosine calculations. 768 if self.diff_data.calc_ddi: 769 self.diff_data.calc_ddi(data, self.diff_data) 770 771 # Diffusion tensor weight calculations. 772 if self.diff_data.calc_dci: 773 self.diff_data.calc_dci(data, self.diff_data) 774 775 # Diffusion tensor correlation times. 776 self.diff_data.calc_dti(data, self.diff_data) 777 778 # Calculate the spectral density gradient components. 779 if data.calc_djw_comps: 780 data.calc_djw_comps(data, data.param_values) 781 782 # Loop over the gradient. 783 for j in xrange(data.total_num_params): 784 # Calculate the spectral density gradients. 785 if data.calc_djw[j]: 786 data.djw = data.calc_djw[j](data, data.param_values, j) 787 else: 788 data.djw = data.djw * 0.0 789 790 # Calculate the relaxation gradient components. 791 data.create_dri_comps(data, data.param_values) 792 793 # Calculate the R1, R2, and sigma_noe gradients. 794 data.dri_prime[j] = data.create_dri_prime[j](data) 795 796 # Loop over the relaxation values and modify the NOE gradients. 797 data.dri[j] = data.dri_prime[j] 798 for m in xrange(data.num_ri): 799 if data.create_dri[m]: 800 data.create_dri[m](data, m, data.remap_table[m], data.get_dr1, params, j) 801 802 # Calculate the chi-squared gradient. 803 data.dchi2[j] = dchi2_element(data.relax_data, data.ri, data.dri[j], data.errors) 804 805 # Index for the construction of the global generic model-free gradient. 806 index = self.diff_data.num_params 807 808 # Diffusion parameter part of the global generic model-free gradient. 809 self.total_dchi2[0:index] = self.total_dchi2[0:index] + data.dchi2[0:index] 810 811 # Diagonal scaling. 812 if self.scaling_flag: 813 self.total_dchi2 = dot(self.total_dchi2, self.scaling_matrix) 814 815 # Return a copy of the gradient. 816 return self.total_dchi2 * 1.0

817 818

819 - def dfunc_all(self, params):

820 """Function for calculating the chi-squared gradient. 821 822 Used in the minimisation of diffusion tensor parameters together with all model-free 823 parameters. 824 """ 825 826 # Test if the function has already been called, otherwise run self.func. 827 if sum(params == self.func_test) != self.total_num_params: 828 self.func(params) 829 830 # Store the parameter values in self.grad_test for testing. 831 self.grad_test = params * 1.0 832 833 # Scaling. 834 if self.scaling_flag: 835 params = dot(params, self.scaling_matrix) 836 837 # Diffusion tensor parameters. 838 self.diff_data.params = params[0:self.diff_end_index] 839 840 # Set the total chi2 gradient to zero. 841 self.total_dchi2 = self.total_dchi2 * 0.0 842 843 # Loop over the residues. 844 for i in xrange(self.num_spins): 845 # Set self.data[i] to data. 846 data = self.data[i] 847 848 # Direction cosine calculations. 849 if self.diff_data.calc_ddi: 850 self.diff_data.calc_ddi(data, self.diff_data) 851 852 # Diffusion tensor weight calculations. 853 if self.diff_data.calc_dci: 854 self.diff_data.calc_dci(data, self.diff_data) 855 856 # Diffusion tensor correlation times. 857 self.diff_data.calc_dti(data, self.diff_data) 858 859 # Calculate the spectral density gradient components. 860 if data.calc_djw_comps: 861 data.calc_djw_comps(data, params) 862 863 # Loop over the gradient. 864 for j in xrange(data.total_num_params): 865 # Calculate the spectral density gradients. 866 if data.calc_djw[j]: 867 data.djw = data.calc_djw[j](data, params, j) 868 else: 869 data.djw = data.djw * 0.0 870 871 # Calculate the relaxation gradient components. 872 data.create_dri_comps(data, params) 873 874 # Calculate the R1, R2, and sigma_noe gradients. 875 data.dri_prime[j] = data.create_dri_prime[j](data) 876 877 # Loop over the relaxation values and modify the NOE gradients. 878 data.dri[j] = data.dri_prime[j] 879 for m in xrange(data.num_ri): 880 if data.create_dri[m]: 881 data.create_dri[m](data, m, data.remap_table[m], data.get_dr1, params, j) 882 883 # Calculate the chi-squared gradient. 884 data.dchi2[j] = dchi2_element(data.relax_data, data.ri, data.dri[j], data.errors) 885 886 # Index for the construction of the global generic model-free gradient. 887 index = self.diff_data.num_params 888 889 # Diffusion parameter part of the global generic model-free gradient. 890 self.total_dchi2[0:index] = self.total_dchi2[0:index] + data.dchi2[0:index] 891 892 # Model-free parameter part of the global generic model-free gradient. 893 self.total_dchi2[data.start_index:data.end_index] = self.total_dchi2[data.start_index:data.end_index] + data.dchi2[index:] 894 895 # Diagonal scaling. 896 if self.scaling_flag: 897 self.total_dchi2 = dot(self.total_dchi2, self.scaling_matrix) 898 899 # Return a copy of the gradient. 900 return self.total_dchi2 * 1.0

901 902

903 - def d2func_mf(self, params):

904 """Function for calculating the chi-squared Hessian. 905 906 Used in the minimisation of model-free parameters for a single residue. 907 """ 908 909 # Test if the gradient has already been called, otherwise run self.dfunc. 910 if sum(params == self.grad_test) != self.total_num_params: 911 self.dfunc(params) 912 913 # Set self.data[0] to data. 914 data = self.data[0] 915 916 # Scaling. 917 if self.scaling_flag: 918 params = dot(params, self.scaling_matrix) 919 920 # Loop over the lower triangle of the Hessian. 921 for j in xrange(data.total_num_params): 922 for k in xrange(j + 1): 923 # Calculate the spectral density Hessians. 924 if data.calc_d2jw[j][k]: 925 data.d2jw = data.calc_d2jw[j][k](data, params, j, k) 926 else: 927 data.d2jw = data.d2jw * 0.0 928 929 # Calculate the relaxation Hessian components. 930 data.create_d2ri_comps(data, params) 931 932 # Calculate the R1, R2, and sigma_noe Hessians. 933 if data.create_d2ri_prime[j][k]: 934 data.d2ri_prime[j, k] = data.create_d2ri_prime[j][k](data) 935 936 # Loop over the relaxation values and modify the NOE Hessians. 937 data.d2ri[j, k] = data.d2ri_prime[j, k] 938 for m in xrange(data.num_ri): 939 if data.create_d2ri[m]: 940 data.create_d2ri[m](data, m, data.remap_table[m], data.get_d2r1, params, j, k) 941 942 # Calculate the chi-squared Hessian. 943 data.d2chi2[j, k] = data.d2chi2[k, j] = d2chi2_element(data.relax_data, data.ri, data.dri[j], data.dri[k], data.d2ri[j, k], data.errors) 944 945 # Diagonal scaling. 946 if self.scaling_flag: 947 data.d2chi2 = dot(self.scaling_matrix, dot(data.d2chi2, self.scaling_matrix)) 948 949 # Return a copy of the Hessian. 950 return data.d2chi2 * 1.0

951 952

953 - def d2func_local_tm(self, params):

954 """Function for calculating the chi-squared Hessian. 955 956 Used in the minimisation of model-free parameters for a single residue with a local tm. 957 """ 958 959 # Test if the gradient has already been called, otherwise run self.dfunc. 960 if sum(params == self.grad_test) != self.total_num_params: 961 self.dfunc(params) 962 963 # Set self.data[0] to data. 964 data = self.data[0] 965 966 # Scaling. 967 if self.scaling_flag: 968 params = dot(params, self.scaling_matrix) 969 970 # Diffusion tensor parameters. 971 self.diff_data.params = params[0:1] 972 973 # Loop over the lower triangle of the Hessian. 974 for j in xrange(data.total_num_params): 975 for k in xrange(j + 1): 976 # Calculate the spectral density Hessians. 977 if data.calc_d2jw[j][k]: 978 data.d2jw = data.calc_d2jw[j][k](data, params, j, k) 979 else: 980 data.d2jw = data.d2jw * 0.0 981 982 # Calculate the relaxation Hessian components. 983 data.create_d2ri_comps(data, params) 984 985 # Calculate the R1, R2, and sigma_noe Hessians. 986 if data.create_d2ri_prime[j][k]: 987 data.d2ri_prime[j, k] = data.create_d2ri_prime[j][k](data) 988 989 # Loop over the relaxation values and modify the NOE Hessians. 990 data.d2ri[j, k] = data.d2ri_prime[j, k] 991 for m in xrange(data.num_ri): 992 if data.create_d2ri[m]: 993 data.create_d2ri[m](data, m, data.remap_table[m], data.get_d2r1, params, j, k) 994 995 # Calculate the chi-squared Hessian. 996 data.d2chi2[j, k] = data.d2chi2[k, j] = d2chi2_element(data.relax_data, data.ri, data.dri[j], data.dri[k], data.d2ri[j, k], data.errors) 997 998 # Diagonal scaling. 999 if self.scaling_flag: 1000 data.d2chi2 = dot(self.scaling_matrix, dot(data.d2chi2, self.scaling_matrix)) 1001 1002 # Return a copy of the Hessian. 1003 return data.d2chi2 * 1.0

1004 1005

1006 - def d2func_diff(self, params):

1007 """Function for calculating the chi-squared Hessian. 1008 1009 Used in the minimisation of diffusion tensor parameters with all model-free parameters 1010 fixed. 1011 """ 1012 1013 # Test if the gradient has already been called, otherwise run self.dfunc. 1014 if sum(params == self.grad_test) != self.total_num_params: 1015 self.dfunc(params) 1016 1017 # Scaling. 1018 if self.scaling_flag: 1019 params = dot(params, self.scaling_matrix) 1020 1021 # Diffusion tensor parameters. 1022 self.diff_data.params = params[0:self.diff_end_index] 1023 1024 # Set the total chi2 Hessian to zero. 1025 self.total_d2chi2 = self.total_d2chi2 * 0.0 1026 1027 # Loop over the residues. 1028 for i in xrange(self.num_spins): 1029 # Set self.data[i] to data. 1030 data = self.data[i] 1031 1032 # Direction cosine calculations. 1033 if self.diff_data.calc_d2di: 1034 self.diff_data.calc_d2di(data, self.diff_data) 1035 1036 # Diffusion tensor weight calculations. 1037 if self.diff_data.calc_d2ci: 1038 self.diff_data.calc_d2ci(data, self.diff_data) 1039 1040 # Diffusion tensor correlation times. 1041 if self.diff_data.calc_d2ti: 1042 self.diff_data.calc_d2ti(data, self.diff_data) 1043 1044 # Loop over the lower triangle of the Hessian. 1045 for j in xrange(data.total_num_params): 1046 for k in xrange(j + 1): 1047 # Calculate the spectral density Hessians. 1048 if data.calc_d2jw[j][k]: 1049 data.d2jw = data.calc_d2jw[j][k](data, data.param_values, j, k) 1050 else: 1051 data.d2jw = data.d2jw * 0.0 1052 1053 # Calculate the relaxation Hessian components. 1054 data.create_d2ri_comps(data, data.param_values) 1055 1056 # Calculate the R1, R2, and sigma_noe Hessians. 1057 if data.create_d2ri_prime[j][k]: 1058 data.d2ri_prime[j, k] = data.create_d2ri_prime[j][k](data) 1059 1060 # Loop over the relaxation values and modify the NOE Hessians. 1061 data.d2ri[j, k] = data.d2ri_prime[j, k] 1062 for m in xrange(data.num_ri): 1063 if data.create_d2ri[m]: 1064 data.create_d2ri[m](data, m, data.remap_table[m], data.get_d2r1, params, j, k) 1065 1066 # Calculate the chi-squared Hessian. 1067 data.d2chi2[j, k] = data.d2chi2[k, j] = d2chi2_element(data.relax_data, data.ri, data.dri[j], data.dri[k], data.d2ri[j, k], data.errors) 1068 1069 # Pure diffusion parameter part of the global generic model-free Hessian. 1070 self.total_d2chi2 = self.total_d2chi2 + data.d2chi2 1071 1072 # Diagonal scaling. 1073 if self.scaling_flag: 1074 self.total_d2chi2 = dot(self.scaling_matrix, dot(self.total_d2chi2, self.scaling_matrix)) 1075 1076 # Return a copy of the Hessian. 1077 return self.total_d2chi2 * 1.0

1078 1079

1080 - def d2func_all(self, params):

1081 """Function for calculating the chi-squared Hessian. 1082 1083 Used in the minimisation of diffusion tensor parameters together with all model-free 1084 parameters. 1085 """ 1086 1087 # Test if the gradient has already been called, otherwise run self.dfunc. 1088 if sum(params == self.grad_test) != self.total_num_params: 1089 self.dfunc(params) 1090 1091 # Scaling. 1092 if self.scaling_flag: 1093 params = dot(params, self.scaling_matrix) 1094 1095 # Diffusion tensor parameters. 1096 self.diff_data.params = params[0:self.diff_end_index] 1097 1098 # Set the total chi2 Hessian to zero. 1099 self.total_d2chi2 = self.total_d2chi2 * 0.0 1100 1101 # Loop over the residues. 1102 for i in xrange(self.num_spins): 1103 # Set self.data[i] to data. 1104 data = self.data[i] 1105 1106 # Direction cosine calculations. 1107 if self.diff_data.calc_d2di: 1108 self.diff_data.calc_d2di(data, self.diff_data) 1109 1110 # Diffusion tensor weight calculations. 1111 if self.diff_data.calc_d2ci: 1112 self.diff_data.calc_d2ci(data, self.diff_data) 1113 1114 # Diffusion tensor correlation times. 1115 if self.diff_data.calc_d2ti: 1116 self.diff_data.calc_d2ti(data, self.diff_data) 1117 1118 # Loop over the lower triangle of the Hessian. 1119 for j in xrange(data.total_num_params): 1120 for k in xrange(j + 1): 1121 # Calculate the spectral density Hessians. 1122 if data.calc_d2jw[j][k]: 1123 data.d2jw = data.calc_d2jw[j][k](data, params, j, k) 1124 else: 1125 data.d2jw = data.d2jw * 0.0 1126 1127 # Calculate the relaxation Hessian components. 1128 data.create_d2ri_comps(data, params) 1129 1130 # Calculate the R1, R2, and sigma_noe Hessians. 1131 if data.create_d2ri_prime[j][k]: 1132 data.d2ri_prime[j, k] = data.create_d2ri_prime[j][k](data) 1133 1134 # Loop over the relaxation values and modify the NOE Hessians. 1135 data.d2ri[j, k] = data.d2ri_prime[j, k] 1136 for m in xrange(data.num_ri): 1137 if data.create_d2ri[m]: 1138 data.create_d2ri[m](data, m, data.remap_table[m], data.get_d2r1, params, j, k) 1139 1140 # Calculate the chi-squared Hessian. 1141 data.d2chi2[j, k] = data.d2chi2[k, j] = d2chi2_element(data.relax_data, data.ri, data.dri[j], data.dri[k], data.d2ri[j, k], data.errors) 1142 1143 # Index for the construction of the global generic model-free Hessian. 1144 index = self.diff_data.num_params 1145 1146 # Pure diffusion parameter part of the global generic model-free Hessian. 1147 self.total_d2chi2[0:index, 0:index] = self.total_d2chi2[0:index, 0:index] + data.d2chi2[0:index, 0:index] 1148 1149 # Pure model-free parameter part of the global generic model-free Hessian. 1150 self.total_d2chi2[data.start_index:data.end_index, data.start_index:data.end_index] = self.total_d2chi2[data.start_index:data.end_index, data.start_index:data.end_index] + data.d2chi2[index:, index:] 1151 1152 # Off diagonal diffusion and model-free parameter parts of the global generic model-free Hessian. 1153 self.total_d2chi2[0:index, data.start_index:data.end_index] = self.total_d2chi2[0:index, data.start_index:data.end_index] + data.d2chi2[0:index, index:] 1154 self.total_d2chi2[data.start_index:data.end_index, 0:index] = self.total_d2chi2[data.start_index:data.end_index, 0:index] + data.d2chi2[index:, 0:index] 1155 1156 # Diagonal scaling. 1157 if self.scaling_flag: 1158 self.total_d2chi2 = dot(self.scaling_matrix, dot(self.total_d2chi2, self.scaling_matrix)) 1159 1160 # Return a copy of the Hessian. 1161 return self.total_d2chi2 * 1.0

1162 1163

1164 - def calc_ri(self):

1165 """Function for calculating relaxation values.""" 1166 1167 # Function call. 1168 chi2 = self.func_mf(self.params) 1169 1170 # Return the single value. 1171 return self.data[0].ri[0]

1172 1173

1174 - def init_diff_data(self, diff_data):

1175 """Function for the initialisation of diffusion tensor specific data.""" 1176 1177 # Diffusion as an sphere. 1178 if diff_data.type == 'sphere': 1179 # Number of diffusion parameters. 1180 diff_data.num_params = 1 1181 1182 # Number of indices in the generic equations. 1183 diff_data.num_indices = 1 1184 1185 # Direction cosine function, gradient, and Hessian. 1186 diff_data.calc_di = None 1187 diff_data.calc_ddi = None 1188 diff_data.calc_d2di = None 1189 1190 # Weight function, gradient, and Hessian. 1191 diff_data.calc_ci = calc_sphere_ci 1192 diff_data.calc_dci = None 1193 diff_data.calc_d2ci = None 1194 1195 # Global correlation time function, gradient, and Hessian. 1196 diff_data.calc_ti = calc_sphere_ti 1197 diff_data.calc_dti = calc_sphere_dti 1198 diff_data.calc_d2ti = None 1199 1200 1201 # Diffusion as an spheroid. 1202 elif diff_data.type == 'spheroid': 1203 # Number of diffusion parameters. 1204 diff_data.num_params = 4 1205 1206 # Number of indices in the generic equations. 1207 diff_data.num_indices = 3 1208 1209 # Direction cosine function, gradient, and Hessian. 1210 diff_data.calc_di = calc_spheroid_di 1211 diff_data.calc_ddi = calc_spheroid_ddi 1212 diff_data.calc_d2di = calc_spheroid_d2di 1213 1214 # Weight function, gradient, and Hessian. 1215 diff_data.calc_ci = calc_spheroid_ci 1216 diff_data.calc_dci = calc_spheroid_dci 1217 diff_data.calc_d2ci = calc_spheroid_d2ci 1218 1219 # Global correlation time function, gradient, and Hessian. 1220 diff_data.calc_ti = calc_spheroid_ti 1221 diff_data.calc_dti = calc_spheroid_dti 1222 diff_data.calc_d2ti = calc_spheroid_d2ti 1223 1224 # Unit vectors. 1225 diff_data.dpar = zeros(3, float64) 1226 1227 # Unit vector gradients. 1228 diff_data.dpar_dtheta = zeros(3, float64) 1229 diff_data.dpar_dphi = zeros(3, float64) 1230 1231 # Unit vector Hessians. 1232 diff_data.dpar_dtheta2 = zeros(3, float64) 1233 diff_data.dpar_dthetadphi = zeros(3, float64) 1234 diff_data.dpar_dphi2 = zeros(3, float64) 1235 1236 # Diffusion as an ellipsoid. 1237 elif diff_data.type == 'ellipsoid': 1238 # Number of diffusion parameters. 1239 diff_data.num_params = 6 1240 1241 # Number of indices in the generic equations. 1242 diff_data.num_indices = 5 1243 1244 # Direction cosine function, gradient, and Hessian. 1245 diff_data.calc_di = calc_ellipsoid_di 1246 diff_data.calc_ddi = calc_ellipsoid_ddi 1247 diff_data.calc_d2di = calc_ellipsoid_d2di 1248 1249 # Weight function, gradient, and Hessian. 1250 diff_data.calc_ci = calc_ellipsoid_ci 1251 diff_data.calc_dci = calc_ellipsoid_dci 1252 diff_data.calc_d2ci = calc_ellipsoid_d2ci 1253 1254 # Global correlation time function, gradient, and Hessian. 1255 diff_data.calc_ti = calc_ellipsoid_ti 1256 diff_data.calc_dti = calc_ellipsoid_dti 1257 diff_data.calc_d2ti = calc_ellipsoid_d2ti 1258 1259 # Unit vectors. 1260 diff_data.dx = zeros(3, float64) 1261 diff_data.dy = zeros(3, float64) 1262 diff_data.dz = zeros(3, float64) 1263 1264 # Unit vector gradients. 1265 diff_data.ddx_dalpha = zeros(3, float64) 1266 diff_data.ddx_dbeta = zeros(3, float64) 1267 diff_data.ddx_dgamma = zeros(3, float64) 1268 1269 diff_data.ddy_dalpha = zeros(3, float64) 1270 diff_data.ddy_dbeta = zeros(3, float64) 1271 diff_data.ddy_dgamma = zeros(3, float64) 1272 1273 diff_data.ddz_dalpha = zeros(3, float64) 1274 diff_data.ddz_dbeta = zeros(3, float64) 1275 diff_data.ddz_dgamma = zeros(3, float64) 1276 1277 # Unit vector Hessians. 1278 diff_data.d2dx_dalpha2 = zeros(3, float64) 1279 diff_data.d2dx_dalpha_dbeta = zeros(3, float64) 1280 diff_data.d2dx_dalpha_dgamma = zeros(3, float64) 1281 diff_data.d2dx_dbeta2 = zeros(3, float64) 1282 diff_data.d2dx_dbeta_dgamma = zeros(3, float64) 1283 diff_data.d2dx_dgamma2 = zeros(3, float64) 1284 1285 diff_data.d2dy_dalpha2 = zeros(3, float64) 1286 diff_data.d2dy_dalpha_dbeta = zeros(3, float64) 1287 diff_data.d2dy_dalpha_dgamma = zeros(3, float64) 1288 diff_data.d2dy_dbeta2 = zeros(3, float64) 1289 diff_data.d2dy_dbeta_dgamma = zeros(3, float64) 1290 diff_data.d2dy_dgamma2 = zeros(3, float64) 1291 1292 diff_data.d2dz_dalpha2 = zeros(3, float64) 1293 diff_data.d2dz_dalpha_dbeta = zeros(3, float64) 1294 diff_data.d2dz_dalpha_dgamma = zeros(3, float64) 1295 diff_data.d2dz_dbeta2 = zeros(3, float64) 1296 diff_data.d2dz_dbeta_dgamma = zeros(3, float64) 1297 diff_data.d2dz_dgamma2 = zeros(3, float64)

1298 1299

1300 - def init_res_data(self, data, diff_data):

1301 """Function for the initialisation of the residue specific data.""" 1302 1303 # Correlation times. 1304 data.ci = zeros(diff_data.num_indices, float64) 1305 data.ci_comps = zeros(diff_data.num_indices, float64) 1306 1307 # Weights. 1308 data.ti = zeros(diff_data.num_indices, float64) 1309 data.tau_comps = zeros(diff_data.num_indices, float64) 1310 data.tau_comps_sqrd = zeros(diff_data.num_indices, float64) 1311 data.tau_comps_cubed = zeros(diff_data.num_indices, float64) 1312 data.tau_scale = zeros(diff_data.num_indices, float64) 1313 1314 # Diffusion as a sphere. 1315 if self.diff_data.type == 'sphere': 1316 # Global correlation time gradient and Hessian. 1317 data.dti = zeros((1, diff_data.num_indices), float64) 1318 data.d2ti = zeros((1, 1, diff_data.num_indices), float64) 1319 1320 # Diffusion as a spheroid. 1321 elif self.diff_data.type == 'spheroid': 1322 # Weight gradient and Hessian. 1323 data.dci = zeros((4, diff_data.num_indices), float64) 1324 data.d2ci = zeros((4, 4, diff_data.num_indices), float64) 1325 1326 # Global correlation time gradient and Hessian. 1327 data.dti = zeros((2, diff_data.num_indices), float64) 1328 data.d2ti = zeros((2, 2, diff_data.num_indices), float64) 1329 1330 # Dot product. 1331 data.dz = 0 1332 1333 # Dot product gradient. 1334 data.ddz_dO = zeros(2, float64) 1335 1336 # Dot product Hessian. 1337 data.d2dz_dO2 = zeros((2, 2), float64) 1338 1339 # Diffusion as an ellipsoid. 1340 elif self.diff_data.type == 'ellipsoid': 1341 # Weight gradient and Hessian. 1342 data.dci = zeros((6, diff_data.num_indices), float64) 1343 data.d2ci = zeros((6, 6, diff_data.num_indices), float64) 1344 1345 # Global correlation time gradient and Hessian. 1346 data.dti = zeros((3, diff_data.num_indices), float64) 1347 data.d2ti = zeros((3, 3, diff_data.num_indices), float64) 1348 1349 # Dot products. 1350 data.dx = 0.0 1351 data.dy = 0.0 1352 data.dz = 0.0 1353 1354 # Dot product gradients. 1355 data.ddx_dO = zeros(3, float64) 1356 data.ddy_dO = zeros(3, float64) 1357 data.ddz_dO = zeros(3, float64) 1358 1359 # Dot product Hessians. 1360 data.d2dx_dO2 = zeros((3, 3), float64) 1361 data.d2dy_dO2 = zeros((3, 3), float64) 1362 data.d2dz_dO2 = zeros((3, 3), float64) 1363 1364 # Empty spectral density components. 1365 data.w_ti_sqrd = zeros((data.num_frq, 5, diff_data.num_indices), float64) 1366 data.fact_ti = zeros((data.num_frq, 5, diff_data.num_indices), float64) 1367 data.w_te_ti_sqrd = zeros((data.num_frq, 5, diff_data.num_indices), float64) 1368 data.w_tf_ti_sqrd = zeros((data.num_frq, 5, diff_data.num_indices), float64) 1369 data.w_ts_ti_sqrd = zeros((data.num_frq, 5, diff_data.num_indices), float64) 1370 data.inv_te_denom = zeros((data.num_frq, 5, diff_data.num_indices), float64) 1371 data.inv_tf_denom = zeros((data.num_frq, 5, diff_data.num_indices), float64) 1372 data.inv_ts_denom = zeros((data.num_frq, 5, diff_data.num_indices), float64) 1373 1374 # Empty spectral density values, gradients, and Hessians. 1375 data.jw = zeros((data.num_frq, 5), float64) 1376 data.djw = zeros((data.num_frq, 5), float64) 1377 data.d2jw = zeros((data.num_frq, 5), float64) 1378 1379 # Calculate the fixed components of the dipolar and CSA constants. 1380 data.csa_const_fixed = zeros(data.num_frq, float64) 1381 data.dip_const_fixed = None 1382 calc_fixed_csa(data) 1383 calc_fixed_dip(data) 1384 1385 # Dipolar and CSA constants. 1386 data.dip_const_func = 0.0 1387 data.dip_const_grad = 0.0 1388 data.dip_const_hess = 0.0 1389 data.csa_const_func = zeros(data.num_frq, float64) 1390 data.csa_const_grad = zeros(data.num_frq, float64) 1391 data.csa_const_hess = zeros(data.num_frq, float64) 1392 1393 # Components of the transformed relaxation equations. 1394 data.dip_comps_func = zeros(data.num_ri, float64) 1395 data.csa_comps_func = zeros(data.num_ri, float64) 1396 data.rex_comps_func = zeros(data.num_ri, float64) 1397 data.dip_jw_comps_func = zeros(data.num_ri, float64) 1398 data.csa_jw_comps_func = zeros(data.num_ri, float64) 1399 1400 # First partial derivative components of the transformed relaxation equations. 1401 data.dip_comps_grad = zeros(data.num_ri, float64) 1402 data.csa_comps_grad = zeros(data.num_ri, float64) 1403 data.rex_comps_grad = zeros(data.num_ri, float64) 1404 data.dip_jw_comps_grad = zeros(data.num_ri, float64) 1405 data.csa_jw_comps_grad = zeros(data.num_ri, float64) 1406 1407 # First partial derivative components of the transformed relaxation equations. 1408 data.dip_comps_hess = zeros(data.num_ri, float64) 1409 data.csa_comps_hess = zeros(data.num_ri, float64) 1410 data.rex_comps_hess = zeros(data.num_ri, float64) 1411 data.dip_jw_comps_hess = zeros(data.num_ri, float64) 1412 data.csa_jw_comps_hess = zeros(data.num_ri, float64) 1413 1414 # Transformed relaxation values, gradients, and Hessians. 1415 data.ri_prime = zeros((data.num_ri), float64) 1416 data.dri_prime = zeros((data.total_num_params, data.num_ri), float64) 1417 data.d2ri_prime = zeros((data.total_num_params, data.total_num_params, data.num_ri), float64) 1418 1419 # Data structures containing the Ri values. 1420 data.ri = zeros(data.num_ri, float64) 1421 data.dri = zeros((data.total_num_params, data.num_ri), float64) 1422 data.d2ri = zeros((data.total_num_params, data.total_num_params, data.num_ri), float64) 1423 1424 # Data structures containing the R1 values at the position of and corresponding to the NOE. 1425 data.r1 = zeros(data.num_ri, float64) 1426 data.dr1 = zeros((data.total_num_params, data.num_ri), float64) 1427 data.d2r1 = zeros((data.total_num_params, data.total_num_params, data.num_ri), float64) 1428 1429 # Data structures containing the chi-squared values. 1430 data.chi2 = 0.0 1431 data.dchi2 = zeros((data.total_num_params), float64) 1432 data.d2chi2 = zeros((data.total_num_params, data.total_num_params), float64)

1433 1434

1435 - def init_res_r1_data(self, data):

1436 """Function for initialisation of the R1 data class. 1437 1438 This data class is only used if an NOE data set is collected but no R1 data set 1439 corresponding to the same frequency exists. 1440 """ 1441 1442 # Initialise an instance of Data. 1443 r1_data = Data() 1444 1445 # Copy a few things from 'data' to 'r1_data' 1446 r1_data.num_frq = data.num_frq 1447 r1_data.dip_const_fixed = data.dip_const_fixed 1448 r1_data.csa_const_fixed = data.csa_const_fixed 1449 1450 # Components of the transformed relaxation equations. 1451 r1_data.dip_comps_func = zeros(data.num_ri, float64) 1452 r1_data.csa_comps_func = zeros(data.num_ri, float64) 1453 r1_data.dip_jw_comps_func = zeros(data.num_ri, float64) 1454 r1_data.csa_jw_comps_func = zeros(data.num_ri, float64) 1455 1456 # Initialise the first partial derivative components of the transformed relaxation equations. 1457 r1_data.dip_comps_grad = zeros(data.num_ri, float64) 1458 r1_data.csa_comps_grad = zeros(data.num_ri, float64) 1459 r1_data.rex_comps_grad = zeros(data.num_ri, float64) 1460 r1_data.dip_jw_comps_grad = zeros(data.num_ri, float64) 1461 r1_data.csa_jw_comps_grad = zeros(data.num_ri, float64) 1462 1463 # Initialise the first partial derivative components of the transformed relaxation equations. 1464 r1_data.dip_comps_hess = zeros(data.num_ri, float64) 1465 r1_data.csa_comps_hess = zeros(data.num_ri, float64) 1466 r1_data.rex_comps_hess = zeros(data.num_ri, float64) 1467 r1_data.dip_jw_comps_hess = zeros(data.num_ri, float64) 1468 r1_data.csa_jw_comps_hess = zeros(data.num_ri, float64) 1469 1470 # Initialise the transformed relaxation values, gradients, and Hessians. 1471 r1_data.ri_prime = zeros(data.num_ri, float64) 1472 r1_data.dri_prime = zeros((data.num_ri, data.total_num_params), float64) 1473 r1_data.d2ri_prime = zeros((data.num_ri, data.total_num_params, data.total_num_params), float64) 1474 1475 # Place a few function arrays in the data class for the calculation of the R1 value when an NOE data set exists but the R1 set does not. 1476 r1_data.create_dri_prime = data.create_dri_prime 1477 r1_data.create_d2ri_prime = data.create_d2ri_prime 1478 1479 # CSA, bond length, and Rex indices. 1480 r1_data.csa_i = data.csa_i 1481 r1_data.r_i = data.r_i 1482 r1_data.rex_i = data.rex_i 1483 1484 # Place 'r1_data' into 'data'. 1485 data.r1_data = r1_data

1486 1487

1488 - def lm_dri(self):

1489 """Return the function used for Levenberg-Marquardt minimisation.""" 1490 1491 # Create dri. 1492 if self.model_type == 'mf' or self.model_type == 'local_tm': 1493 dri = self.data[0].dri 1494 elif self.model_type == 'diff': 1495 # Set the total dri gradient to zero. 1496 self.total_dri = self.total_dri * 0.0 1497 1498 # Ri indices. 1499 ri_start_index = 0 1500 ri_end_index = 0 1501 1502 # Loop over the residues. 1503 for i in xrange(self.num_spins): 1504 # Set self.data[i] to data. 1505 data = self.data[i] 1506 1507 # Increment Ri end index. 1508 ri_end_index = ri_end_index + data.num_ri 1509 1510 # Diffusion parameter part of the global generic model-free gradient. 1511 self.total_dri[0:self.diff_data.num_params, ri_start_index:ri_end_index] = self.total_dri[0:self.diff_data.num_params, ri_start_index:ri_end_index] + data.dri[0:self.diff_data.num_params] 1512 1513 # Increment Ri start index. 1514 ri_start_index = ri_start_index + data.num_ri 1515 1516 # dri. 1517 dri = self.total_dri 1518 1519 elif self.model_type == 'all': 1520 # Set the total dri gradient to zero. 1521 self.total_dri = self.total_dri * 0.0 1522 1523 # Ri indices. 1524 ri_start_index = 0 1525 ri_end_index = 0 1526 1527 # Loop over the residues. 1528 for i in xrange(self.num_spins): 1529 # Set self.data[i] to data. 1530 data = self.data[i] 1531 1532 # Increment Ri end index. 1533 ri_end_index = ri_end_index + data.num_ri 1534 1535 # Diffusion parameter part of the global generic model-free gradient. 1536 self.total_dri[0:self.diff_data.num_params, ri_start_index:ri_end_index] = self.total_dri[0:self.diff_data.num_params, ri_start_index:ri_end_index] + data.dri[0:self.diff_data.num_params] 1537 1538 # Model-free parameter part of the global generic model-free gradient. 1539 self.total_dri[data.start_index:data.end_index, ri_start_index:ri_end_index] = self.total_dri[data.start_index:data.end_index, ri_start_index:ri_end_index] + data.dri[self.diff_data.num_params:] 1540 1541 # Increment Ri start index. 1542 ri_start_index = ri_start_index + data.num_ri 1543 1544 # dri. 1545 dri = self.total_dri 1546 1547 # Make the proper Jacobian. 1548 dri = transpose(dri) 1549 1550 # Diagonal scaling. 1551 if self.scaling_flag: 1552 dri = dot(dri, self.scaling_matrix) 1553 1554 # Return dri. 1555 return dri

1556 1557

1558 - def setup_equations(self, data):

1559 """Setup all the residue specific equations.""" 1560 1561 # Initialisation. 1562 ################# 1563 1564 # The number of diffusion parameters. 1565 if self.model_type != 'all': 1566 num_diff_params = 0 1567 elif self.diff_data.type == 'sphere': 1568 num_diff_params = 1 1569 elif self.diff_data.type == 'spheroid': 1570 num_diff_params = 4 1571 elif self.diff_data.type == 'ellipsoid': 1572 num_diff_params = 6 1573 1574 # Indices. 1575 data.tm_i, data.tm_li = None, None 1576 data.s2_i, data.s2_li = None, None 1577 data.s2f_i, data.s2f_li = None, None 1578 data.s2s_i, data.s2s_li = None, None 1579 data.te_i, data.te_li = None, None 1580 data.tf_i, data.tf_li = None, None 1581 data.ts_i, data.ts_li = None, None 1582 data.rex_i, data.rex_li = None, None 1583 data.r_i, data.r_li = None, None 1584 data.csa_i, data.csa_li = None, None 1585 1586 # Set up the spectral density functions. 1587 ######################################## 1588 1589 # Create empty spectral density gradient and Hessian function data structures. 1590 data.calc_djw = [] 1591 data.calc_d2jw = [] 1592 for i in xrange(data.total_num_params): 1593 data.calc_djw.append(None) 1594 data.calc_d2jw.append([]) 1595 for j in xrange(data.total_num_params): 1596 data.calc_d2jw[i].append(None) 1597 1598 1599 # The original model-free equations {S2, te, Rex, r, CSA}. 1600 ########################################################## 1601 1602 if data.equations == 'mf_orig': 1603 # Find the indices of the model-free parameters. 1604 for i in xrange(data.num_params): 1605 if data.param_types[i] == 's2': 1606 data.s2_li = num_diff_params + i 1607 data.s2_i = self.param_index + i 1608 elif data.param_types[i] == 'te': 1609 data.te_li = num_diff_params + i 1610 data.te_i = self.param_index + i 1611 elif data.param_types[i] == 'rex': 1612 data.rex_li = num_diff_params + i 1613 data.rex_i = self.param_index + i 1614 elif data.param_types[i] == 'r': 1615 data.r_li = num_diff_params + i 1616 data.r_i = self.param_index + i 1617 elif data.param_types[i] == 'csa': 1618 data.csa_li = num_diff_params + i 1619 data.csa_i = self.param_index + i 1620 elif data.param_types[i] == 'local_tm': 1621 pass 1622 else: 1623 print("Unknown parameter.") 1624 return 0 1625 1626 # Increment the parameter index. 1627 self.param_index = self.param_index + data.num_params 1628 1629 # Single residue minimisation with fixed diffusion parameters. 1630 if self.model_type == 'mf': 1631 # No model-free parameters {}. 1632 if data.s2_i == None and data.te_i == None: 1633 # Equation. 1634 data.calc_jw_comps = None 1635 data.calc_jw = calc_jw 1636 1637 # Gradient. 1638 data.calc_djw_comps = None 1639 1640 # Model-free parameters {S2}. 1641 elif data.s2_i != None and data.te_i == None: 1642 # Equation. 1643 data.calc_jw_comps = None 1644 data.calc_jw = calc_S2_jw 1645 1646 # Gradient. 1647 data.calc_djw_comps = None 1648 data.calc_djw[data.s2_li] = calc_S2_djw_dS2 1649 1650 # Model-free parameters {S2, te}. 1651 elif data.s2_i != None and data.te_i != None: 1652 # Equation. 1653 data.calc_jw_comps = calc_S2_te_jw_comps 1654 data.calc_jw = calc_S2_te_jw 1655 1656 # Gradient. 1657 data.calc_djw_comps = calc_S2_te_djw_comps 1658 data.calc_djw[data.s2_li] = calc_S2_te_djw_dS2 1659 data.calc_djw[data.te_li] = calc_S2_te_djw_dte 1660 1661 # Hessian. 1662 data.calc_d2jw[data.s2_li][data.te_li] = data.calc_d2jw[data.te_li][data.s2_li] = calc_S2_te_d2jw_dS2dte 1663 data.calc_d2jw[data.te_li][data.te_li] = calc_S2_te_d2jw_dte2 1664 1665 # Bad parameter combination. 1666 else: 1667 print("Invalid combination of parameters for the extended model-free equation.") 1668 return 0 1669 1670 # Minimisation with variable diffusion parameters. 1671 else: 1672 # Diffusion parameters and no model-free parameters {}. 1673 if data.s2_i == None and data.te_i == None: 1674 # Equation. 1675 data.calc_jw_comps = None 1676 data.calc_jw = calc_jw 1677 1678 # Gradient. 1679 data.calc_djw_comps = calc_diff_djw_comps 1680 1681 # Diffusion as a sphere. 1682 if self.diff_data.type == 'sphere': 1683 # Gradient. 1684 data.calc_djw[0] = calc_diff_djw_dGj 1685 1686 # Hessian. 1687 data.calc_d2jw[0][0] = calc_diff_d2jw_dGjdGk 1688 1689 # Diffusion as a spheroid. 1690 elif self.diff_data.type == 'spheroid': 1691 # Gradient. 1692 data.calc_djw[0] = data.calc_djw[1] = calc_diff_djw_dGj 1693 data.calc_djw[2] = data.calc_djw[3] = calc_diff_djw_dOj 1694 1695 # Hessian. 1696 data.calc_d2jw[0][0] = calc_diff_d2jw_dGjdGk 1697 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_diff_d2jw_dGjdGk 1698 data.calc_d2jw[1][1] = calc_diff_d2jw_dGjdGk 1699 1700 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_diff_d2jw_dGjdOj 1701 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_diff_d2jw_dGjdOj 1702 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_diff_d2jw_dGjdOj 1703 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_diff_d2jw_dGjdOj 1704 1705 data.calc_d2jw[2][2] = calc_diff_d2jw_dOjdOk 1706 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_diff_d2jw_dOjdOk 1707 data.calc_d2jw[3][3] = calc_diff_d2jw_dOjdOk 1708 1709 # Diffusion as an ellipsoid. 1710 elif self.diff_data.type == 'ellipsoid': 1711 # Gradient. 1712 data.calc_djw[0] = data.calc_djw[1] = data.calc_djw[2] = calc_ellipsoid_djw_dGj 1713 data.calc_djw[3] = data.calc_djw[4] = data.calc_djw[5] = calc_diff_djw_dOj 1714 1715 # Hessian. 1716 data.calc_d2jw[0][0] = calc_ellipsoid_d2jw_dGjdGk 1717 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_ellipsoid_d2jw_dGjdGk 1718 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_ellipsoid_d2jw_dGjdGk 1719 data.calc_d2jw[1][1] = calc_ellipsoid_d2jw_dGjdGk 1720 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_ellipsoid_d2jw_dGjdGk 1721 data.calc_d2jw[2][2] = calc_ellipsoid_d2jw_dGjdGk 1722 1723 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_ellipsoid_d2jw_dGjdOj 1724 data.calc_d2jw[0][4] = data.calc_d2jw[4][0] = calc_ellipsoid_d2jw_dGjdOj 1725 data.calc_d2jw[0][5] = data.calc_d2jw[5][0] = calc_ellipsoid_d2jw_dGjdOj 1726 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_ellipsoid_d2jw_dGjdOj 1727 data.calc_d2jw[1][4] = data.calc_d2jw[4][1] = calc_ellipsoid_d2jw_dGjdOj 1728 data.calc_d2jw[1][5] = data.calc_d2jw[5][1] = calc_ellipsoid_d2jw_dGjdOj 1729 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_ellipsoid_d2jw_dGjdOj 1730 data.calc_d2jw[2][4] = data.calc_d2jw[4][2] = calc_ellipsoid_d2jw_dGjdOj 1731 data.calc_d2jw[2][5] = data.calc_d2jw[5][2] = calc_ellipsoid_d2jw_dGjdOj 1732 1733 data.calc_d2jw[3][3] = calc_diff_d2jw_dOjdOk 1734 data.calc_d2jw[3][4] = data.calc_d2jw[4][3] = calc_diff_d2jw_dOjdOk 1735 data.calc_d2jw[3][5] = data.calc_d2jw[5][3] = calc_diff_d2jw_dOjdOk 1736 data.calc_d2jw[4][4] = calc_diff_d2jw_dOjdOk 1737 data.calc_d2jw[4][5] = data.calc_d2jw[5][4] = calc_diff_d2jw_dOjdOk 1738 data.calc_d2jw[5][5] = calc_diff_d2jw_dOjdOk 1739 1740 # Diffusion parameters and model-free parameters {S2}. 1741 elif data.s2_i != None and data.te_i == None: 1742 # Equation. 1743 data.calc_jw_comps = None 1744 data.calc_jw = calc_S2_jw 1745 1746 # Gradient. 1747 data.calc_djw_comps = calc_diff_djw_comps 1748 1749 if self.model_type != 'diff': 1750 # Gradient. 1751 data.calc_djw[data.s2_li] = calc_S2_djw_dS2 1752 1753 # Diffusion as a sphere. 1754 if self.diff_data.type == 'sphere': 1755 # Gradient. 1756 data.calc_djw[0] = calc_diff_S2_djw_dGj 1757 1758 # Hessian. 1759 data.calc_d2jw[0][0] = calc_diff_S2_d2jw_dGjdGk 1760 if self.model_type != 'diff': 1761 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_diff_S2_d2jw_dGjdS2 1762 1763 # Diffusion as a spheroid. 1764 elif self.diff_data.type == 'spheroid': 1765 # Gradient. 1766 data.calc_djw[0] = data.calc_djw[1] = calc_diff_S2_djw_dGj 1767 data.calc_djw[2] = data.calc_djw[3] = calc_diff_S2_djw_dOj 1768 1769 # Hessian. 1770 data.calc_d2jw[0][0] = calc_diff_S2_d2jw_dGjdGk 1771 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_diff_S2_d2jw_dGjdGk 1772 data.calc_d2jw[1][1] = calc_diff_S2_d2jw_dGjdGk 1773 1774 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_diff_S2_d2jw_dGjdOj 1775 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_diff_S2_d2jw_dGjdOj 1776 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_diff_S2_d2jw_dGjdOj 1777 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_diff_S2_d2jw_dGjdOj 1778 1779 data.calc_d2jw[2][2] = calc_diff_S2_d2jw_dOjdOk 1780 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_diff_S2_d2jw_dOjdOk 1781 data.calc_d2jw[3][3] = calc_diff_S2_d2jw_dOjdOk 1782 1783 if self.model_type != 'diff': 1784 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_diff_S2_d2jw_dGjdS2 1785 data.calc_d2jw[1][data.s2_li] = data.calc_d2jw[data.s2_li][1] = calc_diff_S2_d2jw_dGjdS2 1786 data.calc_d2jw[2][data.s2_li] = data.calc_d2jw[data.s2_li][2] = calc_diff_S2_d2jw_dOjdS2 1787 data.calc_d2jw[3][data.s2_li] = data.calc_d2jw[data.s2_li][3] = calc_diff_S2_d2jw_dOjdS2 1788 1789 # Diffusion as an ellipsoid. 1790 elif self.diff_data.type == 'ellipsoid': 1791 # Gradient. 1792 data.calc_djw[0] = data.calc_djw[1] = data.calc_djw[2] = calc_ellipsoid_S2_djw_dGj 1793 data.calc_djw[3] = data.calc_djw[4] = data.calc_djw[5] = calc_diff_S2_djw_dOj 1794 1795 # Hessian. 1796 data.calc_d2jw[0][0] = calc_ellipsoid_S2_d2jw_dGjdGk 1797 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_ellipsoid_S2_d2jw_dGjdGk 1798 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_ellipsoid_S2_d2jw_dGjdGk 1799 data.calc_d2jw[1][1] = calc_ellipsoid_S2_d2jw_dGjdGk 1800 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_ellipsoid_S2_d2jw_dGjdGk 1801 data.calc_d2jw[2][2] = calc_ellipsoid_S2_d2jw_dGjdGk 1802 1803 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_ellipsoid_S2_d2jw_dGjdOj 1804 data.calc_d2jw[0][4] = data.calc_d2jw[4][0] = calc_ellipsoid_S2_d2jw_dGjdOj 1805 data.calc_d2jw[0][5] = data.calc_d2jw[5][0] = calc_ellipsoid_S2_d2jw_dGjdOj 1806 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_ellipsoid_S2_d2jw_dGjdOj 1807 data.calc_d2jw[1][4] = data.calc_d2jw[4][1] = calc_ellipsoid_S2_d2jw_dGjdOj 1808 data.calc_d2jw[1][5] = data.calc_d2jw[5][1] = calc_ellipsoid_S2_d2jw_dGjdOj 1809 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_ellipsoid_S2_d2jw_dGjdOj 1810 data.calc_d2jw[2][4] = data.calc_d2jw[4][2] = calc_ellipsoid_S2_d2jw_dGjdOj 1811 data.calc_d2jw[2][5] = data.calc_d2jw[5][2] = calc_ellipsoid_S2_d2jw_dGjdOj 1812 1813 data.calc_d2jw[3][3] = calc_diff_S2_d2jw_dOjdOk 1814 data.calc_d2jw[3][4] = data.calc_d2jw[4][3] = calc_diff_S2_d2jw_dOjdOk 1815 data.calc_d2jw[3][5] = data.calc_d2jw[5][3] = calc_diff_S2_d2jw_dOjdOk 1816 data.calc_d2jw[4][4] = calc_diff_S2_d2jw_dOjdOk 1817 data.calc_d2jw[4][5] = data.calc_d2jw[5][4] = calc_diff_S2_d2jw_dOjdOk 1818 data.calc_d2jw[5][5] = calc_diff_S2_d2jw_dOjdOk 1819 1820 if self.model_type != 'diff': 1821 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_ellipsoid_S2_d2jw_dGjdS2 1822 data.calc_d2jw[1][data.s2_li] = data.calc_d2jw[data.s2_li][1] = calc_ellipsoid_S2_d2jw_dGjdS2 1823 data.calc_d2jw[2][data.s2_li] = data.calc_d2jw[data.s2_li][2] = calc_ellipsoid_S2_d2jw_dGjdS2 1824 data.calc_d2jw[3][data.s2_li] = data.calc_d2jw[data.s2_li][3] = calc_diff_S2_d2jw_dOjdS2 1825 data.calc_d2jw[4][data.s2_li] = data.calc_d2jw[data.s2_li][4] = calc_diff_S2_d2jw_dOjdS2 1826 data.calc_d2jw[5][data.s2_li] = data.calc_d2jw[data.s2_li][5] = calc_diff_S2_d2jw_dOjdS2 1827 1828 1829 # Diffusion parameters and model-free parameters {S2, te}. 1830 elif data.s2_i != None and data.te_i != None: 1831 # Equation. 1832 data.calc_jw_comps = calc_S2_te_jw_comps 1833 data.calc_jw = calc_S2_te_jw 1834 1835 # Gradient. 1836 data.calc_djw_comps = calc_diff_S2_te_djw_comps 1837 1838 if self.model_type != 'diff': 1839 # Gradient. 1840 data.calc_djw[data.s2_li] = calc_S2_te_djw_dS2 1841 data.calc_djw[data.te_li] = calc_S2_te_djw_dte 1842 1843 # Hessian. 1844 data.calc_d2jw[data.s2_li][data.te_li] = data.calc_d2jw[data.te_li][data.s2_li] = calc_S2_te_d2jw_dS2dte 1845 data.calc_d2jw[data.te_li][data.te_li] = calc_S2_te_d2jw_dte2 1846 1847 # Diffusion as a sphere. 1848 if self.diff_data.type == 'sphere': 1849 # Gradient. 1850 data.calc_djw[0] = calc_diff_S2_te_djw_dGj 1851 1852 # Hessian. 1853 data.calc_d2jw[0][0] = calc_diff_S2_te_d2jw_dGjdGk 1854 if self.model_type != 'diff': 1855 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_diff_S2_te_d2jw_dGjdS2 1856 data.calc_d2jw[0][data.te_li] = data.calc_d2jw[data.te_li][0] = calc_diff_S2_te_d2jw_dGjdte 1857 1858 # Diffusion as a spheroid. 1859 elif self.diff_data.type == 'spheroid': 1860 # Gradient. 1861 data.calc_djw[0] = data.calc_djw[1] = calc_diff_S2_te_djw_dGj 1862 data.calc_djw[2] = data.calc_djw[3] = calc_diff_S2_te_djw_dOj 1863 1864 # Hessian. 1865 data.calc_d2jw[0][0] = calc_diff_S2_te_d2jw_dGjdGk 1866 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_diff_S2_te_d2jw_dGjdGk 1867 data.calc_d2jw[1][1] = calc_diff_S2_te_d2jw_dGjdGk 1868 1869 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_diff_S2_te_d2jw_dGjdOj 1870 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_diff_S2_te_d2jw_dGjdOj 1871 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_diff_S2_te_d2jw_dGjdOj 1872 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_diff_S2_te_d2jw_dGjdOj 1873 1874 data.calc_d2jw[2][2] = calc_diff_S2_te_d2jw_dOjdOk 1875 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_diff_S2_te_d2jw_dOjdOk 1876 data.calc_d2jw[3][3] = calc_diff_S2_te_d2jw_dOjdOk 1877 1878 if self.model_type != 'diff': 1879 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_diff_S2_te_d2jw_dGjdS2 1880 data.calc_d2jw[1][data.s2_li] = data.calc_d2jw[data.s2_li][1] = calc_diff_S2_te_d2jw_dGjdS2 1881 data.calc_d2jw[2][data.s2_li] = data.calc_d2jw[data.s2_li][2] = calc_diff_S2_te_d2jw_dOjdS2 1882 data.calc_d2jw[3][data.s2_li] = data.calc_d2jw[data.s2_li][3] = calc_diff_S2_te_d2jw_dOjdS2 1883 1884 data.calc_d2jw[0][data.te_li] = data.calc_d2jw[data.te_li][0] = calc_diff_S2_te_d2jw_dGjdte 1885 data.calc_d2jw[1][data.te_li] = data.calc_d2jw[data.te_li][1] = calc_diff_S2_te_d2jw_dGjdte 1886 data.calc_d2jw[2][data.te_li] = data.calc_d2jw[data.te_li][2] = calc_diff_S2_te_d2jw_dOjdte 1887 data.calc_d2jw[3][data.te_li] = data.calc_d2jw[data.te_li][3] = calc_diff_S2_te_d2jw_dOjdte 1888 1889 # Diffusion as an ellipsoid. 1890 elif self.diff_data.type == 'ellipsoid': 1891 # Gradient. 1892 data.calc_djw[0] = data.calc_djw[1] = data.calc_djw[2] = calc_ellipsoid_S2_te_djw_dGj 1893 data.calc_djw[3] = data.calc_djw[4] = data.calc_djw[5] = calc_diff_S2_te_djw_dOj 1894 1895 # Hessian. 1896 data.calc_d2jw[0][0] = calc_ellipsoid_S2_te_d2jw_dGjdGk 1897 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_ellipsoid_S2_te_d2jw_dGjdGk 1898 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_ellipsoid_S2_te_d2jw_dGjdGk 1899 data.calc_d2jw[1][1] = calc_ellipsoid_S2_te_d2jw_dGjdGk 1900 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_ellipsoid_S2_te_d2jw_dGjdGk 1901 data.calc_d2jw[2][2] = calc_ellipsoid_S2_te_d2jw_dGjdGk 1902 1903 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_ellipsoid_S2_te_d2jw_dGjdOj 1904 data.calc_d2jw[0][4] = data.calc_d2jw[4][0] = calc_ellipsoid_S2_te_d2jw_dGjdOj 1905 data.calc_d2jw[0][5] = data.calc_d2jw[5][0] = calc_ellipsoid_S2_te_d2jw_dGjdOj 1906 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_ellipsoid_S2_te_d2jw_dGjdOj 1907 data.calc_d2jw[1][4] = data.calc_d2jw[4][1] = calc_ellipsoid_S2_te_d2jw_dGjdOj 1908 data.calc_d2jw[1][5] = data.calc_d2jw[5][1] = calc_ellipsoid_S2_te_d2jw_dGjdOj 1909 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_ellipsoid_S2_te_d2jw_dGjdOj 1910 data.calc_d2jw[2][4] = data.calc_d2jw[4][2] = calc_ellipsoid_S2_te_d2jw_dGjdOj 1911 data.calc_d2jw[2][5] = data.calc_d2jw[5][2] = calc_ellipsoid_S2_te_d2jw_dGjdOj 1912 1913 data.calc_d2jw[3][3] = calc_diff_S2_te_d2jw_dOjdOk 1914 data.calc_d2jw[3][4] = data.calc_d2jw[4][3] = calc_diff_S2_te_d2jw_dOjdOk 1915 data.calc_d2jw[3][5] = data.calc_d2jw[5][3] = calc_diff_S2_te_d2jw_dOjdOk 1916 data.calc_d2jw[4][4] = calc_diff_S2_te_d2jw_dOjdOk 1917 data.calc_d2jw[4][5] = data.calc_d2jw[5][4] = calc_diff_S2_te_d2jw_dOjdOk 1918 data.calc_d2jw[5][5] = calc_diff_S2_te_d2jw_dOjdOk 1919 1920 if self.model_type != 'diff': 1921 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_ellipsoid_S2_te_d2jw_dGjdS2 1922 data.calc_d2jw[1][data.s2_li] = data.calc_d2jw[data.s2_li][1] = calc_ellipsoid_S2_te_d2jw_dGjdS2 1923 data.calc_d2jw[2][data.s2_li] = data.calc_d2jw[data.s2_li][2] = calc_ellipsoid_S2_te_d2jw_dGjdS2 1924 data.calc_d2jw[3][data.s2_li] = data.calc_d2jw[data.s2_li][3] = calc_diff_S2_te_d2jw_dOjdS2 1925 data.calc_d2jw[4][data.s2_li] = data.calc_d2jw[data.s2_li][4] = calc_diff_S2_te_d2jw_dOjdS2 1926 data.calc_d2jw[5][data.s2_li] = data.calc_d2jw[data.s2_li][5] = calc_diff_S2_te_d2jw_dOjdS2 1927 1928 data.calc_d2jw[0][data.te_li] = data.calc_d2jw[data.te_li][0] = calc_ellipsoid_S2_te_d2jw_dGjdte 1929 data.calc_d2jw[1][data.te_li] = data.calc_d2jw[data.te_li][1] = calc_ellipsoid_S2_te_d2jw_dGjdte 1930 data.calc_d2jw[2][data.te_li] = data.calc_d2jw[data.te_li][2] = calc_ellipsoid_S2_te_d2jw_dGjdte 1931 data.calc_d2jw[3][data.te_li] = data.calc_d2jw[data.te_li][3] = calc_diff_S2_te_d2jw_dOjdte 1932 data.calc_d2jw[4][data.te_li] = data.calc_d2jw[data.te_li][4] = calc_diff_S2_te_d2jw_dOjdte 1933 data.calc_d2jw[5][data.te_li] = data.calc_d2jw[data.te_li][5] = calc_diff_S2_te_d2jw_dOjdte 1934 1935 # Bad parameter combination. 1936 else: 1937 print("Invalid combination of parameters for the extended model-free equation.") 1938 return 0 1939 1940 1941 1942 # The extended model-free equations {S2f, tf, S2, ts, Rex, r, CSA}. 1943 ################################################################### 1944 1945 elif data.equations == 'mf_ext': 1946 # Find the indices of the model-free parameters. 1947 for i in xrange(data.num_params): 1948 if data.param_types[i] == 's2f': 1949 data.s2f_li = num_diff_params + i 1950 data.s2f_i = self.param_index + i 1951 elif data.param_types[i] == 'tf': 1952 data.tf_li = num_diff_params + i 1953 data.tf_i = self.param_index + i 1954 elif data.param_types[i] == 's2': 1955 data.s2_li = num_diff_params + i 1956 data.s2_i = self.param_index + i 1957 elif data.param_types[i] == 'ts': 1958 data.ts_li = num_diff_params + i 1959 data.ts_i = self.param_index + i 1960 elif data.param_types[i] == 'rex': 1961 data.rex_li = num_diff_params + i 1962 data.rex_i = self.param_index + i 1963 elif data.param_types[i] == 'r': 1964 data.r_li = num_diff_params + i 1965 data.r_i = self.param_index + i 1966 elif data.param_types[i] == 'csa': 1967 data.csa_li = num_diff_params + i 1968 data.csa_i = self.param_index + i 1969 elif data.param_types[i] == 'local_tm': 1970 pass 1971 else: 1972 print("Unknown parameter.") 1973 return 0 1974 1975 # Increment the parameter index. 1976 self.param_index = self.param_index + data.num_params 1977 1978 # Single residue minimisation with fixed diffusion parameters. 1979 if self.model_type == 'mf': 1980 # Model-free parameters {S2f, S2, ts}. 1981 if data.s2f_i != None and data.tf_i == None and data.s2_i != None and data.ts_i != None: 1982 # Equation. 1983 data.calc_jw_comps = calc_S2f_S2_ts_jw_comps 1984 data.calc_jw = calc_S2f_S2_ts_jw 1985 1986 # Gradient. 1987 data.calc_djw_comps = calc_S2f_S2_ts_djw_comps 1988 data.calc_djw[data.s2f_li] = calc_S2f_S2_ts_djw_dS2f 1989 data.calc_djw[data.s2_li] = calc_S2f_S2_ts_djw_dS2 1990 data.calc_djw[data.ts_li] = calc_S2f_S2_ts_djw_dts 1991 1992 # Hessian. 1993 data.calc_d2jw[data.s2f_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2f_li] = calc_S2f_S2_ts_d2jw_dS2fdts 1994 data.calc_d2jw[data.s2_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2_li] = calc_S2f_S2_ts_d2jw_dS2dts 1995 data.calc_d2jw[data.ts_li][data.ts_li] = calc_S2f_S2_ts_d2jw_dts2 1996 1997 # Model-free parameters {S2f, tf, S2, ts}. 1998 elif data.s2f_i != None and data.tf_i != None and data.s2_i != None and data.ts_i != None: 1999 # Equation. 2000 data.calc_jw_comps = calc_S2f_tf_S2_ts_jw_comps 2001 data.calc_jw = calc_S2f_tf_S2_ts_jw 2002 2003 # Gradient. 2004 data.calc_djw_comps = calc_S2f_tf_S2_ts_djw_comps 2005 data.calc_djw[data.s2f_li] = calc_S2f_tf_S2_ts_djw_dS2f 2006 data.calc_djw[data.tf_li] = calc_S2f_tf_S2_ts_djw_dtf 2007 data.calc_djw[data.s2_li] = calc_S2f_S2_ts_djw_dS2 2008 data.calc_djw[data.ts_li] = calc_S2f_S2_ts_djw_dts 2009 2010 # Hessian. 2011 data.calc_d2jw[data.s2f_li][data.tf_li] = data.calc_d2jw[data.tf_li][data.s2f_li] = calc_S2f_tf_S2_ts_d2jw_dS2fdtf 2012 data.calc_d2jw[data.s2f_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2f_li] = calc_S2f_S2_ts_d2jw_dS2fdts 2013 data.calc_d2jw[data.s2_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2_li] = calc_S2f_S2_ts_d2jw_dS2dts 2014 data.calc_d2jw[data.tf_li][data.tf_li] = calc_S2f_tf_S2_ts_d2jw_dtf2 2015 data.calc_d2jw[data.ts_li][data.ts_li] = calc_S2f_S2_ts_d2jw_dts2 2016 2017 # Bad parameter combination. 2018 else: 2019 print("Invalid combination of parameters for the extended model-free equation.") 2020 return 0 2021 2022 # Minimisation with variable diffusion parameters. 2023 else: 2024 # Diffusion parameters and model-free parameters {S2f, S2, ts}. 2025 if data.s2f_i != None and data.tf_i == None and data.s2_i != None and data.ts_i != None: 2026 # Equation. 2027 data.calc_jw_comps = calc_S2f_S2_ts_jw_comps 2028 data.calc_jw = calc_S2f_S2_ts_jw 2029 2030 # Gradient. 2031 data.calc_djw_comps = calc_diff_S2f_S2_ts_djw_comps 2032 2033 if self.model_type != 'diff': 2034 # Gradient. 2035 data.calc_djw[data.s2f_li] = calc_S2f_S2_ts_djw_dS2f 2036 data.calc_djw[data.s2_li] = calc_S2f_S2_ts_djw_dS2 2037 data.calc_djw[data.ts_li] = calc_S2f_S2_ts_djw_dts 2038 2039 # Hessian. 2040 data.calc_d2jw[data.s2f_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2f_li] = calc_S2f_S2_ts_d2jw_dS2fdts 2041 data.calc_d2jw[data.s2_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2_li] = calc_S2f_S2_ts_d2jw_dS2dts 2042 data.calc_d2jw[data.ts_li][data.ts_li] = calc_S2f_S2_ts_d2jw_dts2 2043 2044 # Diffusion as a sphere. 2045 if self.diff_data.type == 'sphere': 2046 # Gradient. 2047 data.calc_djw[0] = calc_diff_S2f_S2_ts_djw_dGj 2048 2049 # Hessian. 2050 data.calc_d2jw[0][0] = calc_diff_S2f_S2_ts_d2jw_dGjdGk 2051 if self.model_type != 'diff': 2052 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_diff_S2f_S2_ts_d2jw_dGjdS2f 2053 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_diff_S2f_S2_ts_d2jw_dGjdS2 2054 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_diff_S2f_S2_ts_d2jw_dGjdts 2055 2056 # Diffusion as a spheroid. 2057 elif self.diff_data.type == 'spheroid': 2058 # Gradient. 2059 data.calc_djw[0] = data.calc_djw[1] = calc_diff_S2f_S2_ts_djw_dGj 2060 data.calc_djw[2] = data.calc_djw[3] = calc_diff_S2f_S2_ts_djw_dOj 2061 2062 # Hessian. 2063 data.calc_d2jw[0][0] = calc_diff_S2f_S2_ts_d2jw_dGjdGk 2064 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_diff_S2f_S2_ts_d2jw_dGjdGk 2065 data.calc_d2jw[1][1] = calc_diff_S2f_S2_ts_d2jw_dGjdGk 2066 2067 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_diff_S2f_S2_ts_d2jw_dGjdOj 2068 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_diff_S2f_S2_ts_d2jw_dGjdOj 2069 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_diff_S2f_S2_ts_d2jw_dGjdOj 2070 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_diff_S2f_S2_ts_d2jw_dGjdOj 2071 2072 data.calc_d2jw[2][2] = calc_diff_S2f_S2_ts_d2jw_dOjdOk 2073 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_diff_S2f_S2_ts_d2jw_dOjdOk 2074 data.calc_d2jw[3][3] = calc_diff_S2f_S2_ts_d2jw_dOjdOk 2075 2076 if self.model_type != 'diff': 2077 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_diff_S2f_S2_ts_d2jw_dGjdS2f 2078 data.calc_d2jw[1][data.s2f_li] = data.calc_d2jw[data.s2f_li][1] = calc_diff_S2f_S2_ts_d2jw_dGjdS2f 2079 data.calc_d2jw[2][data.s2f_li] = data.calc_d2jw[data.s2f_li][2] = calc_diff_S2f_S2_ts_d2jw_dOjdS2f 2080 data.calc_d2jw[3][data.s2f_li] = data.calc_d2jw[data.s2f_li][3] = calc_diff_S2f_S2_ts_d2jw_dOjdS2f 2081 2082 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_diff_S2f_S2_ts_d2jw_dGjdS2 2083 data.calc_d2jw[1][data.s2_li] = data.calc_d2jw[data.s2_li][1] = calc_diff_S2f_S2_ts_d2jw_dGjdS2 2084 data.calc_d2jw[2][data.s2_li] = data.calc_d2jw[data.s2_li][2] = calc_diff_S2f_S2_ts_d2jw_dOjdS2 2085 data.calc_d2jw[3][data.s2_li] = data.calc_d2jw[data.s2_li][3] = calc_diff_S2f_S2_ts_d2jw_dOjdS2 2086 2087 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_diff_S2f_S2_ts_d2jw_dGjdts 2088 data.calc_d2jw[1][data.ts_li] = data.calc_d2jw[data.ts_li][1] = calc_diff_S2f_S2_ts_d2jw_dGjdts 2089 data.calc_d2jw[2][data.ts_li] = data.calc_d2jw[data.ts_li][2] = calc_diff_S2f_S2_ts_d2jw_dOjdts 2090 data.calc_d2jw[3][data.ts_li] = data.calc_d2jw[data.ts_li][3] = calc_diff_S2f_S2_ts_d2jw_dOjdts 2091 2092 # Diffusion as an ellipsoid. 2093 elif self.diff_data.type == 'ellipsoid': 2094 # Gradient. 2095 data.calc_djw[0] = data.calc_djw[1] = data.calc_djw[2] = calc_ellipsoid_S2f_S2_ts_djw_dGj 2096 data.calc_djw[3] = data.calc_djw[4] = data.calc_djw[5] = calc_diff_S2f_S2_ts_djw_dOj 2097 2098 # Hessian. 2099 data.calc_d2jw[0][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdGk 2100 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdGk 2101 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdGk 2102 data.calc_d2jw[1][1] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdGk 2103 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdGk 2104 data.calc_d2jw[2][2] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdGk 2105 2106 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdOj 2107 data.calc_d2jw[0][4] = data.calc_d2jw[4][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdOj 2108 data.calc_d2jw[0][5] = data.calc_d2jw[5][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdOj 2109 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdOj 2110 data.calc_d2jw[1][4] = data.calc_d2jw[4][1] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdOj 2111 data.calc_d2jw[1][5] = data.calc_d2jw[5][1] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdOj 2112 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdOj 2113 data.calc_d2jw[2][4] = data.calc_d2jw[4][2] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdOj 2114 data.calc_d2jw[2][5] = data.calc_d2jw[5][2] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdOj 2115 2116 data.calc_d2jw[3][3] = calc_diff_S2f_S2_ts_d2jw_dOjdOk 2117 data.calc_d2jw[3][4] = data.calc_d2jw[4][3] = calc_diff_S2f_S2_ts_d2jw_dOjdOk 2118 data.calc_d2jw[3][5] = data.calc_d2jw[5][3] = calc_diff_S2f_S2_ts_d2jw_dOjdOk 2119 data.calc_d2jw[4][4] = calc_diff_S2f_S2_ts_d2jw_dOjdOk 2120 data.calc_d2jw[4][5] = data.calc_d2jw[5][4] = calc_diff_S2f_S2_ts_d2jw_dOjdOk 2121 data.calc_d2jw[5][5] = calc_diff_S2f_S2_ts_d2jw_dOjdOk 2122 2123 if self.model_type != 'diff': 2124 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdS2f 2125 data.calc_d2jw[1][data.s2f_li] = data.calc_d2jw[data.s2f_li][1] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdS2f 2126 data.calc_d2jw[2][data.s2f_li] = data.calc_d2jw[data.s2f_li][2] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdS2f 2127 data.calc_d2jw[3][data.s2f_li] = data.calc_d2jw[data.s2f_li][3] = calc_diff_S2f_S2_ts_d2jw_dOjdS2f 2128 data.calc_d2jw[4][data.s2f_li] = data.calc_d2jw[data.s2f_li][4] = calc_diff_S2f_S2_ts_d2jw_dOjdS2f 2129 data.calc_d2jw[5][data.s2f_li] = data.calc_d2jw[data.s2f_li][5] = calc_diff_S2f_S2_ts_d2jw_dOjdS2f 2130 2131 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdS2 2132 data.calc_d2jw[1][data.s2_li] = data.calc_d2jw[data.s2_li][1] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdS2 2133 data.calc_d2jw[2][data.s2_li] = data.calc_d2jw[data.s2_li][2] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdS2 2134 data.calc_d2jw[3][data.s2_li] = data.calc_d2jw[data.s2_li][3] = calc_diff_S2f_S2_ts_d2jw_dOjdS2 2135 data.calc_d2jw[4][data.s2_li] = data.calc_d2jw[data.s2_li][4] = calc_diff_S2f_S2_ts_d2jw_dOjdS2 2136 data.calc_d2jw[5][data.s2_li] = data.calc_d2jw[data.s2_li][5] = calc_diff_S2f_S2_ts_d2jw_dOjdS2 2137 2138 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdts 2139 data.calc_d2jw[1][data.ts_li] = data.calc_d2jw[data.ts_li][1] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdts 2140 data.calc_d2jw[2][data.ts_li] = data.calc_d2jw[data.ts_li][2] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdts 2141 data.calc_d2jw[3][data.ts_li] = data.calc_d2jw[data.ts_li][3] = calc_diff_S2f_S2_ts_d2jw_dOjdts 2142 data.calc_d2jw[4][data.ts_li] = data.calc_d2jw[data.ts_li][4] = calc_diff_S2f_S2_ts_d2jw_dOjdts 2143 data.calc_d2jw[5][data.ts_li] = data.calc_d2jw[data.ts_li][5] = calc_diff_S2f_S2_ts_d2jw_dOjdts 2144 2145 2146 # Diffusion parameters and model-free parameters {S2f, tf, S2, ts}. 2147 elif data.s2f_i != None and data.tf_i != None and data.s2_i != None and data.ts_i != None: 2148 # Equation. 2149 data.calc_jw_comps = calc_S2f_tf_S2_ts_jw_comps 2150 data.calc_jw = calc_S2f_tf_S2_ts_jw 2151 2152 # Gradient. 2153 data.calc_djw_comps = calc_diff_S2f_tf_S2_ts_djw_comps 2154 2155 if self.model_type != 'diff': 2156 # Gradient. 2157 data.calc_djw[data.s2f_li] = calc_S2f_tf_S2_ts_djw_dS2f 2158 data.calc_djw[data.tf_li] = calc_S2f_tf_S2_ts_djw_dtf 2159 data.calc_djw[data.s2_li] = calc_S2f_S2_ts_djw_dS2 2160 data.calc_djw[data.ts_li] = calc_S2f_S2_ts_djw_dts 2161 2162 # Hessian. 2163 data.calc_d2jw[data.s2f_li][data.tf_li] = data.calc_d2jw[data.tf_li][data.s2f_li] = calc_S2f_tf_S2_ts_d2jw_dS2fdtf 2164 data.calc_d2jw[data.s2f_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2f_li] = calc_S2f_S2_ts_d2jw_dS2fdts 2165 data.calc_d2jw[data.s2_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2_li] = calc_S2f_S2_ts_d2jw_dS2dts 2166 data.calc_d2jw[data.tf_li][data.tf_li] = calc_S2f_tf_S2_ts_d2jw_dtf2 2167 data.calc_d2jw[data.ts_li][data.ts_li] = calc_S2f_S2_ts_d2jw_dts2 2168 2169 # Diffusion as a sphere. 2170 if self.diff_data.type == 'sphere': 2171 # Gradient. 2172 data.calc_djw[0] = calc_diff_S2f_tf_S2_ts_djw_dGj 2173 2174 # Hessian. 2175 data.calc_d2jw[0][0] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdGk 2176 if self.model_type != 'diff': 2177 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdS2f 2178 data.calc_d2jw[0][data.tf_li] = data.calc_d2jw[data.tf_li][0] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdtf 2179 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_diff_S2f_S2_ts_d2jw_dGjdS2 2180 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_diff_S2f_S2_ts_d2jw_dGjdts 2181 2182 # Diffusion as a spheroid. 2183 elif self.diff_data.type == 'spheroid': 2184 # Gradient. 2185 data.calc_djw[0] = data.calc_djw[1] = calc_diff_S2f_tf_S2_ts_djw_dGj 2186 data.calc_djw[2] = data.calc_djw[3] = calc_diff_S2f_tf_S2_ts_djw_dOj 2187 2188 # Hessian. 2189 data.calc_d2jw[0][0] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdGk 2190 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdGk 2191 data.calc_d2jw[1][1] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdGk 2192 2193 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdOj 2194 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdOj 2195 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdOj 2196 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdOj 2197 2198 data.calc_d2jw[2][2] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdOk 2199 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdOk 2200 data.calc_d2jw[3][3] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdOk 2201 2202 if self.model_type != 'diff': 2203 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdS2f 2204 data.calc_d2jw[1][data.s2f_li] = data.calc_d2jw[data.s2f_li][1] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdS2f 2205 data.calc_d2jw[2][data.s2f_li] = data.calc_d2jw[data.s2f_li][2] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdS2f 2206 data.calc_d2jw[3][data.s2f_li] = data.calc_d2jw[data.s2f_li][3] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdS2f 2207 2208 data.calc_d2jw[0][data.tf_li] = data.calc_d2jw[data.tf_li][0] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdtf 2209 data.calc_d2jw[1][data.tf_li] = data.calc_d2jw[data.tf_li][1] = calc_diff_S2f_tf_S2_ts_d2jw_dGjdtf 2210 data.calc_d2jw[2][data.tf_li] = data.calc_d2jw[data.tf_li][2] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdtf 2211 data.calc_d2jw[3][data.tf_li] = data.calc_d2jw[data.tf_li][3] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdtf 2212 2213 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_diff_S2f_S2_ts_d2jw_dGjdS2 2214 data.calc_d2jw[1][data.s2_li] = data.calc_d2jw[data.s2_li][1] = calc_diff_S2f_S2_ts_d2jw_dGjdS2 2215 data.calc_d2jw[2][data.s2_li] = data.calc_d2jw[data.s2_li][2] = calc_diff_S2f_S2_ts_d2jw_dOjdS2 2216 data.calc_d2jw[3][data.s2_li] = data.calc_d2jw[data.s2_li][3] = calc_diff_S2f_S2_ts_d2jw_dOjdS2 2217 2218 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_diff_S2f_S2_ts_d2jw_dGjdts 2219 data.calc_d2jw[1][data.ts_li] = data.calc_d2jw[data.ts_li][1] = calc_diff_S2f_S2_ts_d2jw_dGjdts 2220 data.calc_d2jw[2][data.ts_li] = data.calc_d2jw[data.ts_li][2] = calc_diff_S2f_S2_ts_d2jw_dOjdts 2221 data.calc_d2jw[3][data.ts_li] = data.calc_d2jw[data.ts_li][3] = calc_diff_S2f_S2_ts_d2jw_dOjdts 2222 2223 # Diffusion as an ellipsoid. 2224 elif self.diff_data.type == 'ellipsoid': 2225 # Gradient. 2226 data.calc_djw[0] = data.calc_djw[1] = data.calc_djw[2] = calc_ellipsoid_S2f_tf_S2_ts_djw_dGj 2227 data.calc_djw[3] = data.calc_djw[4] = data.calc_djw[5] = calc_diff_S2f_tf_S2_ts_djw_dOj 2228 2229 # Hessian. 2230 data.calc_d2jw[0][0] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdGk 2231 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdGk 2232 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdGk 2233 data.calc_d2jw[1][1] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdGk 2234 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdGk 2235 data.calc_d2jw[2][2] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdGk 2236 2237 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdOj 2238 data.calc_d2jw[0][4] = data.calc_d2jw[4][0] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdOj 2239 data.calc_d2jw[0][5] = data.calc_d2jw[5][0] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdOj 2240 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdOj 2241 data.calc_d2jw[1][4] = data.calc_d2jw[4][1] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdOj 2242 data.calc_d2jw[1][5] = data.calc_d2jw[5][1] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdOj 2243 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdOj 2244 data.calc_d2jw[2][4] = data.calc_d2jw[4][2] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdOj 2245 data.calc_d2jw[2][5] = data.calc_d2jw[5][2] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdOj 2246 2247 data.calc_d2jw[3][3] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdOk 2248 data.calc_d2jw[3][4] = data.calc_d2jw[4][3] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdOk 2249 data.calc_d2jw[3][5] = data.calc_d2jw[5][3] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdOk 2250 data.calc_d2jw[4][4] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdOk 2251 data.calc_d2jw[4][5] = data.calc_d2jw[5][4] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdOk 2252 data.calc_d2jw[5][5] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdOk 2253 2254 if self.model_type != 'diff': 2255 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdS2f 2256 data.calc_d2jw[1][data.s2f_li] = data.calc_d2jw[data.s2f_li][1] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdS2f 2257 data.calc_d2jw[2][data.s2f_li] = data.calc_d2jw[data.s2f_li][2] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdS2f 2258 data.calc_d2jw[3][data.s2f_li] = data.calc_d2jw[data.s2f_li][3] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdS2f 2259 data.calc_d2jw[4][data.s2f_li] = data.calc_d2jw[data.s2f_li][4] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdS2f 2260 data.calc_d2jw[5][data.s2f_li] = data.calc_d2jw[data.s2f_li][5] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdS2f 2261 2262 data.calc_d2jw[0][data.tf_li] = data.calc_d2jw[data.tf_li][0] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdtf 2263 data.calc_d2jw[1][data.tf_li] = data.calc_d2jw[data.tf_li][1] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdtf 2264 data.calc_d2jw[2][data.tf_li] = data.calc_d2jw[data.tf_li][2] = calc_ellipsoid_S2f_tf_S2_ts_d2jw_dGjdtf 2265 data.calc_d2jw[3][data.tf_li] = data.calc_d2jw[data.tf_li][3] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdtf 2266 data.calc_d2jw[4][data.tf_li] = data.calc_d2jw[data.tf_li][4] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdtf 2267 data.calc_d2jw[5][data.tf_li] = data.calc_d2jw[data.tf_li][5] = calc_diff_S2f_tf_S2_ts_d2jw_dOjdtf 2268 2269 data.calc_d2jw[0][data.s2_li] = data.calc_d2jw[data.s2_li][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdS2 2270 data.calc_d2jw[1][data.s2_li] = data.calc_d2jw[data.s2_li][1] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdS2 2271 data.calc_d2jw[2][data.s2_li] = data.calc_d2jw[data.s2_li][2] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdS2 2272 data.calc_d2jw[3][data.s2_li] = data.calc_d2jw[data.s2_li][3] = calc_diff_S2f_S2_ts_d2jw_dOjdS2 2273 data.calc_d2jw[4][data.s2_li] = data.calc_d2jw[data.s2_li][4] = calc_diff_S2f_S2_ts_d2jw_dOjdS2 2274 data.calc_d2jw[5][data.s2_li] = data.calc_d2jw[data.s2_li][5] = calc_diff_S2f_S2_ts_d2jw_dOjdS2 2275 2276 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdts 2277 data.calc_d2jw[1][data.ts_li] = data.calc_d2jw[data.ts_li][1] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdts 2278 data.calc_d2jw[2][data.ts_li] = data.calc_d2jw[data.ts_li][2] = calc_ellipsoid_S2f_S2_ts_d2jw_dGjdts 2279 data.calc_d2jw[3][data.ts_li] = data.calc_d2jw[data.ts_li][3] = calc_diff_S2f_S2_ts_d2jw_dOjdts 2280 data.calc_d2jw[4][data.ts_li] = data.calc_d2jw[data.ts_li][4] = calc_diff_S2f_S2_ts_d2jw_dOjdts 2281 data.calc_d2jw[5][data.ts_li] = data.calc_d2jw[data.ts_li][5] = calc_diff_S2f_S2_ts_d2jw_dOjdts 2282 2283 # Bad parameter combination. 2284 else: 2285 print("Invalid combination of parameters for the extended model-free equation.") 2286 return 0 2287 2288 2289 # The extended 2 model-free equations {tm, S2f, tf, S2s, ts, Rex, r, CSA}. 2290 ######################################################################### 2291 2292 elif data.equations == 'mf_ext2': 2293 # Find the indices of the model-free parameters. 2294 for i in xrange(data.num_params): 2295 if data.param_types[i] == 's2f': 2296 data.s2f_li = num_diff_params + i 2297 data.s2f_i = self.param_index + i 2298 elif data.param_types[i] == 'tf': 2299 data.tf_li = num_diff_params + i 2300 data.tf_i = self.param_index + i 2301 elif data.param_types[i] == 's2s': 2302 data.s2s_li = num_diff_params + i 2303 data.s2s_i = self.param_index + i 2304 elif data.param_types[i] == 'ts': 2305 data.ts_li = num_diff_params + i 2306 data.ts_i = self.param_index + i 2307 elif data.param_types[i] == 'rex': 2308 data.rex_li = num_diff_params + i 2309 data.rex_i = self.param_index + i 2310 elif data.param_types[i] == 'r': 2311 data.r_li = num_diff_params + i 2312 data.r_i = self.param_index + i 2313 elif data.param_types[i] == 'csa': 2314 data.csa_li = num_diff_params + i 2315 data.csa_i = self.param_index + i 2316 elif data.param_types[i] == 'local_tm': 2317 pass 2318 else: 2319 print("Unknown parameter.") 2320 return 0 2321 2322 # Increment the parameter index. 2323 self.param_index = self.param_index + data.num_params 2324 2325 # Single residue minimisation with fixed diffusion parameters. 2326 if self.model_type == 'mf': 2327 # Model-free parameters {S2f, S2s, ts}. 2328 if data.s2f_i != None and data.tf_i == None and data.s2s_i != None and data.ts_i != None: 2329 # Equation. 2330 data.calc_jw_comps = calc_S2f_S2s_ts_jw_comps 2331 data.calc_jw = calc_S2f_S2s_ts_jw 2332 2333 # Gradient. 2334 data.calc_djw_comps = calc_S2f_S2s_ts_djw_comps 2335 data.calc_djw[data.s2f_li] = calc_S2f_S2s_ts_djw_dS2f 2336 data.calc_djw[data.s2s_li] = calc_S2f_tf_S2s_ts_djw_dS2s 2337 data.calc_djw[data.ts_li] = calc_S2f_S2s_ts_djw_dts 2338 2339 # Hessian. 2340 data.calc_d2jw[data.s2f_li][data.s2s_li] = data.calc_d2jw[data.s2s_li][data.s2f_li] = calc_S2f_S2s_ts_d2jw_dS2fdS2s 2341 data.calc_d2jw[data.s2f_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2f_li] = calc_S2f_S2s_ts_d2jw_dS2fdts 2342 data.calc_d2jw[data.s2s_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2s_li] = calc_S2f_S2s_ts_d2jw_dS2sdts 2343 data.calc_d2jw[data.ts_li][data.ts_li] = calc_S2f_S2s_ts_d2jw_dts2 2344 2345 # Model-free parameters {S2f, tf, S2s, ts}. 2346 elif data.s2f_i != None and data.tf_i != None and data.s2s_i != None and data.ts_i != None: 2347 # Equation. 2348 data.calc_jw_comps = calc_S2f_tf_S2s_ts_jw_comps 2349 data.calc_jw = calc_S2f_tf_S2s_ts_jw 2350 2351 # Gradient. 2352 data.calc_djw_comps = calc_S2f_tf_S2s_ts_djw_comps 2353 data.calc_djw[data.s2f_li] = calc_S2f_tf_S2s_ts_djw_dS2f 2354 data.calc_djw[data.tf_li] = calc_S2f_tf_S2s_ts_djw_dtf 2355 data.calc_djw[data.s2s_li] = calc_S2f_tf_S2s_ts_djw_dS2s 2356 data.calc_djw[data.ts_li] = calc_S2f_tf_S2s_ts_djw_dts 2357 2358 # Hessian. 2359 data.calc_d2jw[data.s2f_li][data.s2s_li] = data.calc_d2jw[data.s2s_li][data.s2f_li] = calc_S2f_S2s_ts_d2jw_dS2fdS2s 2360 data.calc_d2jw[data.s2f_li][data.tf_li] = data.calc_d2jw[data.tf_li][data.s2f_li] = calc_S2f_tf_S2s_ts_d2jw_dS2fdtf 2361 data.calc_d2jw[data.s2f_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2f_li] = calc_S2f_tf_S2s_ts_d2jw_dS2fdts 2362 data.calc_d2jw[data.s2s_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2s_li] = calc_S2f_tf_S2s_ts_d2jw_dS2sdts 2363 data.calc_d2jw[data.tf_li][data.tf_li] = calc_S2f_tf_S2s_ts_d2jw_dtf2 2364 data.calc_d2jw[data.ts_li][data.ts_li] = calc_S2f_tf_S2s_ts_d2jw_dts2 2365 2366 # Bad parameter combination. 2367 else: 2368 print("Invalid combination of parameters for the extended model-free equation.") 2369 return 0 2370 2371 # Minimisation with variable diffusion parameters. 2372 else: 2373 # Diffusion parameters and model-free parameters {S2f, S2s, ts}. 2374 if data.s2f_i != None and data.tf_i == None and data.s2s_i != None and data.ts_i != None: 2375 # Equation. 2376 data.calc_jw_comps = calc_S2f_S2s_ts_jw_comps 2377 data.calc_jw = calc_S2f_S2s_ts_jw 2378 2379 # Gradient. 2380 data.calc_djw_comps = calc_diff_S2f_S2s_ts_djw_comps 2381 2382 if self.model_type != 'diff': 2383 # Gradient. 2384 data.calc_djw[data.s2f_li] = calc_diff_S2f_S2s_ts_djw_dS2f 2385 data.calc_djw[data.s2s_li] = calc_diff_S2f_S2s_ts_djw_dS2s 2386 data.calc_djw[data.ts_li] = calc_diff_S2f_S2s_ts_djw_dts 2387 2388 # Hessian. 2389 data.calc_d2jw[data.s2f_li][data.s2s_li] = data.calc_d2jw[data.s2s_li][data.s2f_li] = calc_S2f_S2s_ts_d2jw_dS2fdS2s 2390 data.calc_d2jw[data.s2f_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2f_li] = calc_diff_S2f_S2s_ts_d2jw_dS2fdts 2391 data.calc_d2jw[data.s2s_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2s_li] = calc_diff_S2f_S2s_ts_d2jw_dS2sdts 2392 data.calc_d2jw[data.ts_li][data.ts_li] = calc_diff_S2f_S2s_ts_d2jw_dts2 2393 2394 # Diffusion as a sphere. 2395 if self.diff_data.type == 'sphere': 2396 # Gradient. 2397 data.calc_djw[0] = calc_diff_S2f_S2s_ts_djw_dGj 2398 2399 # Hessian. 2400 data.calc_d2jw[0][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdGk 2401 if self.model_type != 'diff': 2402 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdS2f 2403 data.calc_d2jw[0][data.s2s_li] = data.calc_d2jw[data.s2s_li][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdS2s 2404 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdts 2405 2406 # Diffusion as a spheroid. 2407 elif self.diff_data.type == 'spheroid': 2408 # Gradient. 2409 data.calc_djw[0] = data.calc_djw[1] = calc_diff_S2f_S2s_ts_djw_dGj 2410 data.calc_djw[2] = data.calc_djw[3] = calc_diff_S2f_S2s_ts_djw_dOj 2411 2412 # Hessian. 2413 data.calc_d2jw[0][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdGk 2414 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdGk 2415 data.calc_d2jw[1][1] = calc_diff_S2f_S2s_ts_d2jw_dGjdGk 2416 2417 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdOj 2418 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdOj 2419 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_diff_S2f_S2s_ts_d2jw_dGjdOj 2420 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_diff_S2f_S2s_ts_d2jw_dGjdOj 2421 2422 data.calc_d2jw[2][2] = calc_diff_S2f_S2s_ts_d2jw_dOjdOk 2423 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_diff_S2f_S2s_ts_d2jw_dOjdOk 2424 data.calc_d2jw[3][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdOk 2425 2426 if self.model_type != 'diff': 2427 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdS2f 2428 data.calc_d2jw[1][data.s2f_li] = data.calc_d2jw[data.s2f_li][1] = calc_diff_S2f_S2s_ts_d2jw_dGjdS2f 2429 data.calc_d2jw[2][data.s2f_li] = data.calc_d2jw[data.s2f_li][2] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2f 2430 data.calc_d2jw[3][data.s2f_li] = data.calc_d2jw[data.s2f_li][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2f 2431 2432 data.calc_d2jw[0][data.s2s_li] = data.calc_d2jw[data.s2s_li][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdS2s 2433 data.calc_d2jw[1][data.s2s_li] = data.calc_d2jw[data.s2s_li][1] = calc_diff_S2f_S2s_ts_d2jw_dGjdS2s 2434 data.calc_d2jw[2][data.s2s_li] = data.calc_d2jw[data.s2s_li][2] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2s 2435 data.calc_d2jw[3][data.s2s_li] = data.calc_d2jw[data.s2s_li][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2s 2436 2437 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdts 2438 data.calc_d2jw[1][data.ts_li] = data.calc_d2jw[data.ts_li][1] = calc_diff_S2f_S2s_ts_d2jw_dGjdts 2439 data.calc_d2jw[2][data.ts_li] = data.calc_d2jw[data.ts_li][2] = calc_diff_S2f_S2s_ts_d2jw_dOjdts 2440 data.calc_d2jw[3][data.ts_li] = data.calc_d2jw[data.ts_li][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdts 2441 2442 # Diffusion as an ellipsoid. 2443 elif self.diff_data.type == 'ellipsoid': 2444 # Gradient. 2445 data.calc_djw[0] = data.calc_djw[1] = data.calc_djw[2] = calc_ellipsoid_S2f_S2s_ts_djw_dGj 2446 data.calc_djw[3] = data.calc_djw[4] = data.calc_djw[5] = calc_diff_S2f_S2s_ts_djw_dOj 2447 2448 # Hessian. 2449 data.calc_d2jw[0][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdGk 2450 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdGk 2451 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdGk 2452 data.calc_d2jw[1][1] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdGk 2453 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdGk 2454 data.calc_d2jw[2][2] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdGk 2455 2456 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdOj 2457 data.calc_d2jw[0][4] = data.calc_d2jw[4][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdOj 2458 data.calc_d2jw[0][5] = data.calc_d2jw[5][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdOj 2459 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdOj 2460 data.calc_d2jw[1][4] = data.calc_d2jw[4][1] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdOj 2461 data.calc_d2jw[1][5] = data.calc_d2jw[5][1] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdOj 2462 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdOj 2463 data.calc_d2jw[2][4] = data.calc_d2jw[4][2] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdOj 2464 data.calc_d2jw[2][5] = data.calc_d2jw[5][2] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdOj 2465 2466 data.calc_d2jw[3][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdOk 2467 data.calc_d2jw[3][4] = data.calc_d2jw[4][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdOk 2468 data.calc_d2jw[3][5] = data.calc_d2jw[5][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdOk 2469 data.calc_d2jw[4][4] = calc_diff_S2f_S2s_ts_d2jw_dOjdOk 2470 data.calc_d2jw[4][5] = data.calc_d2jw[5][4] = calc_diff_S2f_S2s_ts_d2jw_dOjdOk 2471 data.calc_d2jw[5][5] = calc_diff_S2f_S2s_ts_d2jw_dOjdOk 2472 2473 if self.model_type != 'diff': 2474 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdS2f 2475 data.calc_d2jw[1][data.s2f_li] = data.calc_d2jw[data.s2f_li][1] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdS2f 2476 data.calc_d2jw[2][data.s2f_li] = data.calc_d2jw[data.s2f_li][2] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdS2f 2477 data.calc_d2jw[3][data.s2f_li] = data.calc_d2jw[data.s2f_li][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2f 2478 data.calc_d2jw[4][data.s2f_li] = data.calc_d2jw[data.s2f_li][4] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2f 2479 data.calc_d2jw[5][data.s2f_li] = data.calc_d2jw[data.s2f_li][5] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2f 2480 2481 data.calc_d2jw[0][data.s2s_li] = data.calc_d2jw[data.s2s_li][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdS2s 2482 data.calc_d2jw[1][data.s2s_li] = data.calc_d2jw[data.s2s_li][1] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdS2s 2483 data.calc_d2jw[2][data.s2s_li] = data.calc_d2jw[data.s2s_li][2] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdS2s 2484 data.calc_d2jw[3][data.s2s_li] = data.calc_d2jw[data.s2s_li][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2s 2485 data.calc_d2jw[4][data.s2s_li] = data.calc_d2jw[data.s2s_li][4] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2s 2486 data.calc_d2jw[5][data.s2s_li] = data.calc_d2jw[data.s2s_li][5] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2s 2487 2488 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdts 2489 data.calc_d2jw[1][data.ts_li] = data.calc_d2jw[data.ts_li][1] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdts 2490 data.calc_d2jw[2][data.ts_li] = data.calc_d2jw[data.ts_li][2] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdts 2491 data.calc_d2jw[3][data.ts_li] = data.calc_d2jw[data.ts_li][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdts 2492 data.calc_d2jw[4][data.ts_li] = data.calc_d2jw[data.ts_li][4] = calc_diff_S2f_S2s_ts_d2jw_dOjdts 2493 data.calc_d2jw[5][data.ts_li] = data.calc_d2jw[data.ts_li][5] = calc_diff_S2f_S2s_ts_d2jw_dOjdts 2494 2495 # Diffusion parameters and model-free parameters {S2f, tf, S2s, ts}. 2496 elif data.s2f_i != None and data.tf_i != None and data.s2s_i != None and data.ts_i != None: 2497 # Equation. 2498 data.calc_jw_comps = calc_S2f_tf_S2s_ts_jw_comps 2499 data.calc_jw = calc_S2f_tf_S2s_ts_jw 2500 2501 # Gradient. 2502 data.calc_djw_comps = calc_diff_S2f_tf_S2s_ts_djw_comps 2503 2504 if self.model_type != 'diff': 2505 # Gradient. 2506 data.calc_djw[data.s2f_li] = calc_diff_S2f_tf_S2s_ts_djw_dS2f 2507 data.calc_djw[data.tf_li] = calc_diff_S2f_tf_S2s_ts_djw_dtf 2508 data.calc_djw[data.s2s_li] = calc_diff_S2f_tf_S2s_ts_djw_dS2s 2509 data.calc_djw[data.ts_li] = calc_diff_S2f_tf_S2s_ts_djw_dts 2510 2511 # Hessian. 2512 data.calc_d2jw[data.s2f_li][data.s2s_li] = data.calc_d2jw[data.s2s_li][data.s2f_li] = calc_S2f_S2s_ts_d2jw_dS2fdS2s 2513 data.calc_d2jw[data.s2f_li][data.tf_li] = data.calc_d2jw[data.tf_li][data.s2f_li] = calc_diff_S2f_tf_S2s_ts_d2jw_dS2fdtf 2514 data.calc_d2jw[data.s2f_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2f_li] = calc_diff_S2f_tf_S2s_ts_d2jw_dS2fdts 2515 data.calc_d2jw[data.tf_li][data.tf_li] = calc_diff_S2f_tf_S2s_ts_d2jw_dtf2 2516 data.calc_d2jw[data.s2s_li][data.ts_li] = data.calc_d2jw[data.ts_li][data.s2s_li] = calc_diff_S2f_tf_S2s_ts_d2jw_dS2sdts 2517 data.calc_d2jw[data.ts_li][data.ts_li] = calc_diff_S2f_tf_S2s_ts_d2jw_dts2 2518 2519 # Diffusion as a sphere. 2520 if self.diff_data.type == 'sphere': 2521 # Gradient. 2522 data.calc_djw[0] = calc_diff_S2f_tf_S2s_ts_djw_dGj 2523 2524 # Hessian. 2525 data.calc_d2jw[0][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdGk 2526 if self.model_type != 'diff': 2527 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdS2f 2528 data.calc_d2jw[0][data.tf_li] = data.calc_d2jw[data.tf_li][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdtf 2529 data.calc_d2jw[0][data.s2s_li] = data.calc_d2jw[data.s2s_li][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdS2s 2530 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdts 2531 2532 # Diffusion as a spheroid. 2533 elif self.diff_data.type == 'spheroid': 2534 # Gradient. 2535 data.calc_djw[0] = data.calc_djw[1] = calc_diff_S2f_tf_S2s_ts_djw_dGj 2536 data.calc_djw[2] = data.calc_djw[3] = calc_diff_S2f_tf_S2s_ts_djw_dOj 2537 2538 # Hessian. 2539 data.calc_d2jw[0][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdGk 2540 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdGk 2541 data.calc_d2jw[1][1] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdGk 2542 2543 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdOj 2544 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdOj 2545 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdOj 2546 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdOj 2547 2548 data.calc_d2jw[2][2] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdOk 2549 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdOk 2550 data.calc_d2jw[3][3] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdOk 2551 2552 if self.model_type != 'diff': 2553 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdS2f 2554 data.calc_d2jw[1][data.s2f_li] = data.calc_d2jw[data.s2f_li][1] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdS2f 2555 data.calc_d2jw[2][data.s2f_li] = data.calc_d2jw[data.s2f_li][2] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdS2f 2556 data.calc_d2jw[3][data.s2f_li] = data.calc_d2jw[data.s2f_li][3] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdS2f 2557 2558 data.calc_d2jw[0][data.tf_li] = data.calc_d2jw[data.tf_li][0] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdtf 2559 data.calc_d2jw[1][data.tf_li] = data.calc_d2jw[data.tf_li][1] = calc_diff_S2f_tf_S2s_ts_d2jw_dGjdtf 2560 data.calc_d2jw[2][data.tf_li] = data.calc_d2jw[data.tf_li][2] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdtf 2561 data.calc_d2jw[3][data.tf_li] = data.calc_d2jw[data.tf_li][3] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdtf 2562 2563 data.calc_d2jw[0][data.s2s_li] = data.calc_d2jw[data.s2s_li][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdS2s 2564 data.calc_d2jw[1][data.s2s_li] = data.calc_d2jw[data.s2s_li][1] = calc_diff_S2f_S2s_ts_d2jw_dGjdS2s 2565 data.calc_d2jw[2][data.s2s_li] = data.calc_d2jw[data.s2s_li][2] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2s 2566 data.calc_d2jw[3][data.s2s_li] = data.calc_d2jw[data.s2s_li][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2s 2567 2568 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_diff_S2f_S2s_ts_d2jw_dGjdts 2569 data.calc_d2jw[1][data.ts_li] = data.calc_d2jw[data.ts_li][1] = calc_diff_S2f_S2s_ts_d2jw_dGjdts 2570 data.calc_d2jw[2][data.ts_li] = data.calc_d2jw[data.ts_li][2] = calc_diff_S2f_S2s_ts_d2jw_dOjdts 2571 data.calc_d2jw[3][data.ts_li] = data.calc_d2jw[data.ts_li][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdts 2572 2573 # Diffusion as an ellipsoid. 2574 elif self.diff_data.type == 'ellipsoid': 2575 # Gradient. 2576 data.calc_djw[0] = data.calc_djw[1] = data.calc_djw[2] = calc_ellipsoid_S2f_tf_S2s_ts_djw_dGj 2577 data.calc_djw[3] = data.calc_djw[4] = data.calc_djw[5] = calc_diff_S2f_tf_S2s_ts_djw_dOj 2578 2579 # Hessian. 2580 data.calc_d2jw[0][0] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdGk 2581 data.calc_d2jw[0][1] = data.calc_d2jw[1][0] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdGk 2582 data.calc_d2jw[0][2] = data.calc_d2jw[2][0] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdGk 2583 data.calc_d2jw[1][1] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdGk 2584 data.calc_d2jw[1][2] = data.calc_d2jw[2][1] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdGk 2585 data.calc_d2jw[2][2] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdGk 2586 2587 data.calc_d2jw[0][3] = data.calc_d2jw[3][0] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdOj 2588 data.calc_d2jw[0][4] = data.calc_d2jw[4][0] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdOj 2589 data.calc_d2jw[0][5] = data.calc_d2jw[5][0] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdOj 2590 data.calc_d2jw[1][3] = data.calc_d2jw[3][1] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdOj 2591 data.calc_d2jw[1][4] = data.calc_d2jw[4][1] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdOj 2592 data.calc_d2jw[1][5] = data.calc_d2jw[5][1] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdOj 2593 data.calc_d2jw[2][3] = data.calc_d2jw[3][2] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdOj 2594 data.calc_d2jw[2][4] = data.calc_d2jw[4][2] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdOj 2595 data.calc_d2jw[2][5] = data.calc_d2jw[5][2] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdOj 2596 2597 data.calc_d2jw[3][3] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdOk 2598 data.calc_d2jw[3][4] = data.calc_d2jw[4][3] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdOk 2599 data.calc_d2jw[3][5] = data.calc_d2jw[5][3] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdOk 2600 data.calc_d2jw[4][4] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdOk 2601 data.calc_d2jw[4][5] = data.calc_d2jw[5][4] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdOk 2602 data.calc_d2jw[5][5] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdOk 2603 2604 if self.model_type != 'diff': 2605 data.calc_d2jw[0][data.s2f_li] = data.calc_d2jw[data.s2f_li][0] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdS2f 2606 data.calc_d2jw[1][data.s2f_li] = data.calc_d2jw[data.s2f_li][1] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdS2f 2607 data.calc_d2jw[2][data.s2f_li] = data.calc_d2jw[data.s2f_li][2] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdS2f 2608 data.calc_d2jw[3][data.s2f_li] = data.calc_d2jw[data.s2f_li][3] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdS2f 2609 data.calc_d2jw[4][data.s2f_li] = data.calc_d2jw[data.s2f_li][4] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdS2f 2610 data.calc_d2jw[5][data.s2f_li] = data.calc_d2jw[data.s2f_li][5] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdS2f 2611 2612 data.calc_d2jw[0][data.tf_li] = data.calc_d2jw[data.tf_li][0] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdtf 2613 data.calc_d2jw[1][data.tf_li] = data.calc_d2jw[data.tf_li][1] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdtf 2614 data.calc_d2jw[2][data.tf_li] = data.calc_d2jw[data.tf_li][2] = calc_ellipsoid_S2f_tf_S2s_ts_d2jw_dGjdtf 2615 data.calc_d2jw[3][data.tf_li] = data.calc_d2jw[data.tf_li][3] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdtf 2616 data.calc_d2jw[4][data.tf_li] = data.calc_d2jw[data.tf_li][4] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdtf 2617 data.calc_d2jw[5][data.tf_li] = data.calc_d2jw[data.tf_li][5] = calc_diff_S2f_tf_S2s_ts_d2jw_dOjdtf 2618 2619 data.calc_d2jw[0][data.s2s_li] = data.calc_d2jw[data.s2s_li][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdS2s 2620 data.calc_d2jw[1][data.s2s_li] = data.calc_d2jw[data.s2s_li][1] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdS2s 2621 data.calc_d2jw[2][data.s2s_li] = data.calc_d2jw[data.s2s_li][2] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdS2s 2622 data.calc_d2jw[3][data.s2s_li] = data.calc_d2jw[data.s2s_li][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2s 2623 data.calc_d2jw[4][data.s2s_li] = data.calc_d2jw[data.s2s_li][4] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2s 2624 data.calc_d2jw[5][data.s2s_li] = data.calc_d2jw[data.s2s_li][5] = calc_diff_S2f_S2s_ts_d2jw_dOjdS2s 2625 2626 data.calc_d2jw[0][data.ts_li] = data.calc_d2jw[data.ts_li][0] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdts 2627 data.calc_d2jw[1][data.ts_li] = data.calc_d2jw[data.ts_li][1] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdts 2628 data.calc_d2jw[2][data.ts_li] = data.calc_d2jw[data.ts_li][2] = calc_ellipsoid_S2f_S2s_ts_d2jw_dGjdts 2629 data.calc_d2jw[3][data.ts_li] = data.calc_d2jw[data.ts_li][3] = calc_diff_S2f_S2s_ts_d2jw_dOjdts 2630 data.calc_d2jw[4][data.ts_li] = data.calc_d2jw[data.ts_li][4] = calc_diff_S2f_S2s_ts_d2jw_dOjdts 2631 data.calc_d2jw[5][data.ts_li] = data.calc_d2jw[data.ts_li][5] = calc_diff_S2f_S2s_ts_d2jw_dOjdts 2632 2633 # Bad parameter combination. 2634 else: 2635 print("Invalid combination of parameters for the extended model-free equation.") 2636 return 0 2637 2638 # Unknown model-free equation. 2639 else: 2640 print("Unknown model-free equation.") 2641 return 0 2642 2643 2644 # Initialise function data structures. 2645 ###################################### 2646 2647 # Relaxation equation components. 2648 data.create_dip_func, data.create_dip_grad, data.create_dip_hess = [], [], [] 2649 data.create_csa_func, data.create_csa_grad, data.create_csa_hess = [], [], [] 2650 data.create_rex_func, data.create_rex_grad = [], [] 2651 2652 data.create_dip_jw_func, data.create_dip_jw_grad, data.create_dip_jw_hess = [], [], [] 2653 data.create_csa_jw_func, data.create_csa_jw_grad, data.create_csa_jw_hess = [], [], [] 2654 2655 # Ri' 2656 data.create_ri_prime = None 2657 data.create_dri_prime = [] 2658 data.create_d2ri_prime = [] 2659 2660 # Ri 2661 data.create_ri, data.create_dri, data.create_d2ri = [], [], [] 2662 data.get_r1, data.get_dr1, data.get_d2r1 = [], [], [] 2663 2664 # Fill the structures with None. 2665 for i in xrange(data.num_ri): 2666 data.create_dip_func.append(None) 2667 data.create_dip_grad.append(None) 2668 data.create_dip_hess.append(None) 2669 data.create_csa_func.append(None) 2670 data.create_csa_grad.append(None) 2671 data.create_csa_hess.append(None) 2672 data.create_rex_func.append(None) 2673 data.create_rex_grad.append(None) 2674 data.create_dip_jw_func.append(None) 2675 data.create_dip_jw_grad.append(None) 2676 data.create_dip_jw_hess.append(None) 2677 data.create_csa_jw_func.append(None) 2678 data.create_csa_jw_grad.append(None) 2679 data.create_csa_jw_hess.append(None) 2680 data.create_ri.append(None) 2681 data.create_dri.append(None) 2682 data.create_d2ri.append(None) 2683 data.get_r1.append(None) 2684 data.get_dr1.append(None) 2685 data.get_d2r1.append(None) 2686 2687 2688 # Select the functions for the calculation of ri_prime, dri_prime, and d2ri_prime components. 2689 ############################################################################################# 2690 2691 for i in xrange(data.num_ri): 2692 # The R1 equations. 2693 if data.ri_labels[i] == 'R1': 2694 data.create_csa_func[i] = comp_r1_csa_const 2695 data.create_csa_grad[i] = comp_r1_csa_const 2696 data.create_csa_hess[i] = comp_r1_csa_const 2697 data.create_dip_jw_func[i] = comp_r1_dip_jw 2698 data.create_dip_jw_grad[i] = comp_r1_dip_jw 2699 data.create_dip_jw_hess[i] = comp_r1_dip_jw 2700 data.create_csa_jw_func[i] = comp_r1_csa_jw 2701 data.create_csa_jw_grad[i] = comp_r1_csa_jw 2702 data.create_csa_jw_hess[i] = comp_r1_csa_jw 2703 2704 # The R2 equations. 2705 elif data.ri_labels[i] == 'R2': 2706 data.create_dip_func[i] = comp_r2_dip_const 2707 data.create_dip_grad[i] = comp_r2_dip_const 2708 data.create_dip_hess[i] = comp_r2_dip_const 2709 data.create_csa_func[i] = comp_r2_csa_const 2710 data.create_csa_grad[i] = comp_r2_csa_const 2711 data.create_csa_hess[i] = comp_r2_csa_const 2712 data.create_rex_func[i] = comp_rex_const_func 2713 data.create_rex_grad[i] = comp_rex_const_grad 2714 data.create_dip_jw_func[i] = comp_r2_dip_jw 2715 data.create_dip_jw_grad[i] = comp_r2_dip_jw 2716 data.create_dip_jw_hess[i] = comp_r2_dip_jw 2717 data.create_csa_jw_func[i] = comp_r2_csa_jw 2718 data.create_csa_jw_grad[i] = comp_r2_csa_jw 2719 data.create_csa_jw_hess[i] = comp_r2_csa_jw 2720 2721 # The NOE equations. 2722 elif data.ri_labels[i] == 'NOE': 2723 data.create_dip_jw_func[i] = comp_sigma_noe_dip_jw 2724 data.create_dip_jw_grad[i] = comp_sigma_noe_dip_jw 2725 data.create_dip_jw_hess[i] = comp_sigma_noe_dip_jw 2726 data.create_ri[i] = calc_noe 2727 data.create_dri[i] = calc_dnoe 2728 data.create_d2ri[i] = calc_d2noe 2729 if data.noe_r1_table[i] == None: 2730 data.get_r1[i] = calc_r1 2731 data.get_dr1[i] = calc_dr1 2732 data.get_d2r1[i] = calc_d2r1 2733 else: 2734 data.get_r1[i] = extract_r1 2735 data.get_dr1[i] = extract_dr1 2736 data.get_d2r1[i] = extract_d2r1 2737 2738 2739 # Select the functions for the calculation of ri_prime, dri_prime, and d2ri_prime. 2740 ################################################################################## 2741 2742 # ri_prime. 2743 if data.rex_i == None: 2744 data.create_ri_prime = func_ri_prime 2745 else: 2746 data.create_ri_prime = func_ri_prime_rex 2747 2748 # dri_prime and d2ri_prime. 2749 for i in xrange(data.total_num_params): 2750 # Diffusion tensor parameters are the only parameters. 2751 if self.model_type == 'diff': 2752 # Gradient. 2753 data.create_dri_prime.append(func_dri_djw_prime) 2754 2755 # Hessian. 2756 data.create_d2ri_prime.append([]) 2757 for j in xrange(data.total_num_params): 2758 data.create_d2ri_prime[i].append(func_d2ri_djwidjwj_prime) 2759 2760 # Skip to the next parameter index. 2761 continue 2762 2763 # Residue specific parameter index. 2764 index = i - num_diff_params 2765 if index < 0: 2766 index = None 2767 2768 # Rex. 2769 if index != None and data.param_types[index] == 'rex': 2770 # Gradient. 2771 data.create_dri_prime.append(func_dri_drex_prime) 2772 2773 # Hessian. 2774 data.create_d2ri_prime.append([]) 2775 for j in xrange(data.total_num_params): 2776 # Residue specific parameter index. 2777 index2 = j - num_diff_params 2778 if index2 < 0: 2779 index2 = None 2780 2781 # Rex. 2782 if index2 != None and data.param_types[index2] == 'rex': 2783 data.create_d2ri_prime[i].append(None) 2784 2785 # Bond length. 2786 elif index2 != None and data.param_types[index2] == 'r': 2787 data.create_d2ri_prime[i].append(None) 2788 2789 # CSA. 2790 elif index2 != None and data.param_types[index2] == 'csa': 2791 data.create_d2ri_prime[i].append(None) 2792 2793 # Any other parameter. 2794 else: 2795 data.create_d2ri_prime[i].append(None) 2796 2797 # Bond length. 2798 elif index != None and data.param_types[index] == 'r': 2799 # Gradient. 2800 data.create_dri_prime.append(func_dri_dr_prime) 2801 2802 # Hessian. 2803 data.create_d2ri_prime.append([]) 2804 for j in xrange(data.total_num_params): 2805 # Residue specific parameter index. 2806 index2 = j - num_diff_params 2807 if index2 < 0: 2808 index2 = None 2809 2810 # Rex. 2811 if index2 != None and data.param_types[index2] == 'rex': 2812 data.create_d2ri_prime[i].append(None) 2813 2814 # Bond length. 2815 elif index2 != None and data.param_types[index2] == 'r': 2816 data.create_d2ri_prime[i].append(func_d2ri_dr2_prime) 2817 2818 # CSA. 2819 elif index2 != None and data.param_types[index2] == 'csa': 2820 data.create_d2ri_prime[i].append(None) 2821 2822 # Any other parameter. 2823 else: 2824 data.create_d2ri_prime[i].append(func_d2ri_djwdr_prime) 2825 2826 # CSA. 2827 elif index != None and data.param_types[index] == 'csa': 2828 # Gradient. 2829 data.create_dri_prime.append(func_dri_dcsa_prime) 2830 2831 # Hessian. 2832 data.create_d2ri_prime.append([]) 2833 for j in xrange(data.total_num_params): 2834 # Residue specific parameter index. 2835 index2 = j - num_diff_params 2836 if index2 < 0: 2837 index2 = None 2838 2839 # Rex. 2840 if index2 != None and data.param_types[index2] == 'rex': 2841 data.create_d2ri_prime[i].append(None) 2842 2843 # Bond length. 2844 elif index2 != None and data.param_types[index2] == 'r': 2845 data.create_d2ri_prime[i].append(None) 2846 2847 # CSA. 2848 elif index2 != None and data.param_types[index2] == 'csa': 2849 data.create_d2ri_prime[i].append(func_d2ri_dcsa2_prime) 2850 2851 # Any other parameter. 2852 else: 2853 data.create_d2ri_prime[i].append(func_d2ri_djwdcsa_prime) 2854 2855 # Any other parameter. 2856 else: 2857 # Gradient. 2858 data.create_dri_prime.append(func_dri_djw_prime) 2859 2860 # Hessian. 2861 data.create_d2ri_prime.append([]) 2862 for j in xrange(data.total_num_params): 2863 # Residue specific parameter index. 2864 index2 = j - num_diff_params 2865 if index2 < 0: 2866 index2 = None 2867 2868 # Rex. 2869 if index2 != None and data.param_types[index2] == 'rex': 2870 data.create_d2ri_prime[i].append(None) 2871 2872 # Bond length. 2873 elif index2 != None and data.param_types[index2] == 'r': 2874 data.create_d2ri_prime[i].append(func_d2ri_djwdr_prime) 2875 2876 # CSA. 2877 elif index2 != None and data.param_types[index2] == 'csa': 2878 data.create_d2ri_prime[i].append(func_d2ri_djwdcsa_prime) 2879 2880 # Any other parameter. 2881 else: 2882 data.create_d2ri_prime[i].append(func_d2ri_djwidjwj_prime) 2883 2884 2885 # Both the bond length and CSA are fixed {}. 2886 ############################################ 2887 2888 if data.r_i == None and data.csa_i == None: 2889 # The main ri component functions 2890 if data.rex_i == None: 2891 data.create_ri_comps = ri_comps 2892 data.create_dri_comps = dri_comps 2893 data.create_d2ri_comps = d2ri_comps 2894 else: 2895 data.create_ri_comps = ri_comps_rex 2896 data.create_dri_comps = dri_comps_rex 2897 data.create_d2ri_comps = d2ri_comps 2898 2899 # Calculate the dipolar and CSA constant components. 2900 comp_dip_const_func(data, data.bond_length) 2901 comp_csa_const_func(data, data.csa) 2902 for i in xrange(data.num_ri): 2903 data.dip_comps_func[i] = data.dip_const_func 2904 if data.create_dip_func[i]: 2905 data.dip_comps_func[i] = data.create_dip_func[i](data.dip_const_func) 2906 if data.create_csa_func[i]: 2907 data.csa_comps_func[i] = data.create_csa_func[i](data.csa_const_func[data.remap_table[i]]) 2908 2909 2910 # The bond length is a parameter {r}. 2911 ##################################### 2912 2913 elif data.r_i != None and data.csa_i == None: 2914 # The main ri component functions 2915 if data.rex_i == None: 2916 data.create_ri_comps = ri_comps_r 2917 data.create_dri_comps = dri_comps_r 2918 data.create_d2ri_comps = d2ri_comps_r 2919 else: 2920 data.create_ri_comps = ri_comps_r_rex 2921 data.create_dri_comps = dri_comps_r_rex 2922 data.create_d2ri_comps = d2ri_comps_r 2923 2924 # Calculate the CSA constant. 2925 comp_csa_const_func(data, data.csa) 2926 for i in xrange(data.num_ri): 2927 if data.create_csa_func[i]: 2928 data.csa_comps_func[i] = data.create_csa_func[i](data.csa_const_func[data.remap_table[i]]) 2929 2930 2931 # The CSA is a parameter {CSA}. 2932 ############################### 2933 2934 elif data.r_i == None and data.csa_i != None: 2935 # The main ri component functions 2936 if data.rex_i == None: 2937 data.create_ri_comps = ri_comps_csa 2938 data.create_dri_comps = dri_comps_csa 2939 data.create_d2ri_comps = d2ri_comps_csa 2940 else: 2941 data.create_ri_comps = ri_comps_csa_rex 2942 data.create_dri_comps = dri_comps_csa_rex 2943 data.create_d2ri_comps = d2ri_comps_csa 2944 2945 # Calculate the dipolar constant. 2946 comp_dip_const_func(data, data.bond_length) 2947 for i in xrange(data.num_ri): 2948 data.dip_comps_func[i] = data.dip_const_func 2949 if data.create_dip_func[i]: 2950 data.dip_comps_func[i] = data.create_dip_func[i](data.dip_const_func) 2951 2952 2953 # Both the bond length and CSA are parameters {r, CSA}. 2954 ####################################################### 2955 2956 elif data.r_i != None and data.csa_i != None: 2957 # The main ri component functions 2958 if data.rex_i == None: 2959 data.create_ri_comps = ri_comps_r_csa 2960 data.create_dri_comps = dri_comps_r_csa 2961 data.create_d2ri_comps = d2ri_comps_r_csa 2962 else: 2963 data.create_ri_comps = ri_comps_r_csa_rex 2964 data.create_dri_comps = dri_comps_r_csa_rex 2965 data.create_d2ri_comps = d2ri_comps_r_csa 2966 2967 2968 # Invalid combination of parameters. 2969 #################################### 2970 2971 else: 2972 print("Invalid combination of parameters for the model-free equations.") 2973 return 0 2974 2975 return 1

Source Code for Module maths_fns.mf