target_functions.mf

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

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

379 380

381 - def func_mf(self, params):

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

430 431

432 - def func_local_tm(self, params):

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

484 485

486 - def func_diff(self, params):

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

551 552

553 - def func_all(self, params):

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

618 619

620 - def dfunc_mf(self, params):

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

673 674

675 - def dfunc_local_tm(self, params):

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

734 735

736 - def dfunc_diff(self, params):

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

816 817

818 - def dfunc_all(self, params):

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

900 901

902 - def d2func_mf(self, params):

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

950 951

952 - def d2func_local_tm(self, params):

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

1003 1004

1005 - def d2func_diff(self, params):

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

1077 1078

1079 - def d2func_all(self, params):

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

1161 1162

1163 - def calc_ri(self):

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

1171 1172

1173 - def init_diff_data(self, diff_data):

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

1297 1298

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

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

1432 1433

1434 - def init_res_r1_data(self, data):

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

1485 1486

1487 - def lm_dri(self):

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

1555 1556

1557 - def setup_equations(self, data):

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

Source Code for Module target_functions.mf