target_functions.mf

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

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

381 382

383 - def func_mf(self, params):

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

432 433

434 - def func_local_tm(self, params):

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

486 487

488 - def func_diff(self, params):

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

553 554

555 - def func_all(self, params):

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

620 621

622 - def dfunc_mf(self, params):

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

675 676

677 - def dfunc_local_tm(self, params):

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

736 737

738 - def dfunc_diff(self, params):

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

818 819

820 - def dfunc_all(self, params):

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

902 903

904 - def d2func_mf(self, params):

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

952 953

954 - def d2func_local_tm(self, params):

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

1005 1006

1007 - def d2func_diff(self, params):

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

1079 1080

1081 - def d2func_all(self, params):

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

1163 1164

1165 - def calc_ri(self):

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

1173 1174

1175 - def init_diff_data(self, diff_data):

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

1299 1300

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

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

1434 1435

1436 - def init_res_r1_data(self, data):

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

1487 1488

1489 - def lm_dri(self):

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

1557 1558

1559 - def setup_equations(self, data):

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

Source Code for Module target_functions.mf