Trees       Indices       Help   
relax
Package maths_fns :: Module ri_comps
[hide private]
[frames] | no frames]

Source Code for Module maths_fns.ri_comps

   1  ############################################################################### 
   2  #                                                                             # 
   3  # Copyright (C) 2003-2005 Edward d'Auvergne                                   # 
   4  #                                                                             # 
   5  # This file is part of the program relax.                                     # 
   6  #                                                                             # 
   7  # relax is free software; you can redistribute it and/or modify               # 
   8  # it under the terms of the GNU General Public License as published by        # 
   9  # the Free Software Foundation; either version 2 of the License, or           # 
  10  # (at your option) any later version.                                         # 
  11  #                                                                             # 
  12  # relax is distributed in the hope that it will be useful,                    # 
  13  # but WITHOUT ANY WARRANTY; without even the implied warranty of              # 
  14  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               # 
  15  # GNU General Public License for more details.                                # 
  16  #                                                                             # 
  17  # You should have received a copy of the GNU General Public License           # 
  18  # along with relax; if not, write to the Free Software                        # 
  19  # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA   # 
  20  #                                                                             # 
  21  ############################################################################### 
  22   
  23   
  24  # Constant formulae 
  25  # ~~~~~~~~~~~~~~~~~ 
  26  # 
  27  #    Dipolar constants 
  28  #    ~~~~~~~~~~~~~~~~~ 
  29  #                           1   / mu0  \ 2  (gH.gN.h_bar)**2 
  30  #        dip_const_func  =  - . | ---- |  . ---------------- 
  31  #                           4   \ 4.pi /         <r**6> 
  32  # 
  33  # 
  34  #                             3   / mu0  \ 2  (gH.gN.h_bar)**2 
  35  #        dip_const_grad  =  - - . | ---- |  . ---------------- 
  36  #                             2   \ 4.pi /         <r**7> 
  37  # 
  38  # 
  39  #                           21   / mu0  \ 2  (gH.gN.h_bar)**2 
  40  #        dip_const_hess  =  -- . | ---- |  . ---------------- 
  41  #                           2    \ 4.pi /         <r**8> 
  42  # 
  43  # 
  44  #    CSA constants 
  45  #    ~~~~~~~~~~~~~ 
  46  #                           (wN.csa)**2 
  47  #        csa_const_func  =  ----------- 
  48  #                                3 
  49  # 
  50  #                           2.wN**2.csa 
  51  #        csa_const_grad  =  ----------- 
  52  #                                3 
  53  # 
  54  #                           2.wN**2 
  55  #        csa_const_hess  =  ------- 
  56  #                              3 
  57  # 
  58  #    Rex constants 
  59  #    ~~~~~~~~~~~~~ 
  60  #        rex_const_func  =  rhoex * (2.pi.wH)**2 
  61  # 
  62  #        rex_const_grad  =  (2.pi.wH)**2 
  63  # 
  64  #        rex_const_hess  =  0 
  65  # 
  66  # 
  67  # Component formulae 
  68  # ~~~~~~~~~~~~~~~~~~ 
  69  # 
  70  #    R1 components 
  71  #    ~~~~~~~~~~~~~ 
  72  # 
  73  #        Dipolar components 
  74  #        ~~~~~~~~~~~~~~~~~~ 
  75  # 
  76  #            dip_R1_func     =  dip_const_func 
  77  # 
  78  #            dip_R1_grad     =  dip_const_grad 
  79  # 
  80  #            dip_R1_hess     =  dip_const_hess 
  81  # 
  82  # 
  83  #        Dipolar spectral density components 
  84  #        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
  85  # 
  86  #            dip_Jw_R1_func  =  J(wH-wN) + 3J(wN) + 6J(wH+wN) 
  87  # 
  88  #                               dJ(wH-wN)         dJ(wN)         dJ(wH+wN) 
  89  #            dip_Jw_R1_grad  =  ---------  +  3 . ------  +  6 . --------- 
  90  #                                  dJw             dJw              dJw 
  91  # 
  92  #                               d2J(wH-wN)          d2J(wN)          d2J(wH+wN) 
  93  #            dip_Jw_R1_hess  =  ----------  +  3 . ---------  +  6 . ---------- 
  94  #                               dJwi.dJwj          dJwi.dJwj         dJwi.dJwj 
  95  # 
  96  # 
  97  #        CSA components 
  98  #        ~~~~~~~~~~~~~~ 
  99  # 
 100  #            csa_R1_func     =  csa_const_func 
 101  # 
 102  #            csa_R1_grad     =  csa_const_grad 
 103  # 
 104  #            csa_R1_hess     =  csa_const_hess 
 105  # 
 106  # 
 107  #        CSA spectral density components 
 108  #        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 109  # 
 110  #            csa_Jw_R1_func  =  J(wN) 
 111  # 
 112  #                               dJ(wN) 
 113  #            csa_Jw_R1_grad  =  ------ 
 114  #                                dJw 
 115  # 
 116  #                                d2J(wN) 
 117  #            csa_Jw_R1_hess  =  --------- 
 118  #                               dJwi.dJwj 
 119  # 
 120  # 
 121  #        Rex components 
 122  #        ~~~~~~~~~~~~~~ 
 123  # 
 124  #            rex_R1_func     =  0 
 125  # 
 126  #            rex_R1_grad     =  0 
 127  # 
 128  #            rex_R1_hess     =  0 
 129  # 
 130  # 
 131  #    R2 components 
 132  #    ~~~~~~~~~~~~~ 
 133  # 
 134  #        Dipolar components 
 135  #        ~~~~~~~~~~~~~~~~~~ 
 136  # 
 137  #            dip_R2_func     =  dip_const_func / 2 
 138  # 
 139  #            dip_R2_grad     =  dip_const_grad / 2 
 140  # 
 141  #            dip_R2_hess     =  dip_const_hess / 2 
 142  # 
 143  # 
 144  #        Dipolar spectral density components 
 145  #        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 146  # 
 147  #            dip_Jw_R2_func  =  4J(0) + J(wH-wN) + 3J(wN) + 6J(wH) + 6J(wH+wN) 
 148  # 
 149  #                                   dJ(0)     dJ(wH-wN)         dJ(wN)         dJ(wH)         dJ(wH+wN) 
 150  #            dip_Jw_R2_grad  =  4 . -----  +  ---------  +  3 . ------  +  6 . ------  +  6 . --------- 
 151  #                                    dJw         dJw             dJw            dJw              dJw 
 152  # 
 153  #                                     d2J(0)      d2J(wH-wN)          d2J(wN)           d2J(wH)          d2J(wH+wN) 
 154  #            dip_Jw_R2_hess  =  4 . ---------  +  ----------  +  3 . ---------  +  6 . ---------  +  6 . ---------- 
 155  #                                   dJwi.dJwj     dJwi.dJwj          dJwi.dJwj         dJwi.dJwj         dJwi.dJwj 
 156  # 
 157  # 
 158  #        CSA components 
 159  #        ~~~~~~~~~~~~~~ 
 160  # 
 161  #            csa_R2_func     =  csa_const_func / 6 
 162  # 
 163  #            csa_R2_grad     =  csa_const_grad / 6 
 164  # 
 165  #            csa_R2_hess     =  csa_const_hess / 6 
 166  # 
 167  # 
 168  #        CSA spectral density components 
 169  #        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 170  # 
 171  #            csa_Jw_R2_func  =  4J(0) + 3J(wN) 
 172  # 
 173  #                                   dJ(0)         dJ(wN) 
 174  #            csa_Jw_R2_grad  =  4 . -----  +  3 . ------ 
 175  #                                    dJw           dJw 
 176  # 
 177  #                                     d2J(0)           d2J(wN) 
 178  #            csa_Jw_R2_hess  =  4 . ---------  +  3 . --------- 
 179  #                                   dJwi.dJwj         dJwi.dJwj 
 180  # 
 181  # 
 182  #        Rex components 
 183  #        ~~~~~~~~~~~~~~ 
 184  # 
 185  #            rex_R2_func     =  rex_const_func 
 186  # 
 187  #            rex_R2_grad     =  rex_const_grad 
 188  # 
 189  #            rex_R2_hess     =  0 
 190  # 
 191  # 
 192  #    sigma_noe components 
 193  #    ~~~~~~~~~~~~~~~~~~~~ 
 194  # 
 195  #        Dipolar components 
 196  #        ~~~~~~~~~~~~~~~~~~ 
 197  # 
 198  #            dip_sigma_noe_func      =  dip_const_func 
 199  # 
 200  #            dip_sigma_noe_grad      =  dip_const_grad 
 201  # 
 202  #            dip_sigma_noe_hess      =  dip_const_hess 
 203  # 
 204  # 
 205  #        Dipolar spectral density components 
 206  #        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 207  # 
 208  #            dip_Jw_sigma_noe_func  =  6J(wH+wN) - J(wH-wN) 
 209  # 
 210  #                                          dJ(wH+wN)     dJ(wH-wN) 
 211  #            dip_Jw_sigma_noe_grad  =  6 . ---------  -  --------- 
 212  #                                             dJw           dJw 
 213  # 
 214  #                                          d2J(wH+wN)     d2J(wH-wN) 
 215  #            dip_Jw_sigma_noe_hess  =  6 . ----------  -  ---------- 
 216  #                                          dJwi.dJwj      dJwi.dJwj 
 217  # 
 218  # 
 219  #        CSA components 
 220  #        ~~~~~~~~~~~~~~ 
 221  # 
 222  #            csa_sigma_noe_func      =  0 
 223  # 
 224  #            csa_sigma_noe_grad      =  0 
 225  # 
 226  #            csa_sigma_noe_hess      =  0 
 227  # 
 228  # 
 229  #        CSA spectral density components 
 230  #        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 231  # 
 232  #            csa_Jw_sigma_noe_func   =  0 
 233  # 
 234  #            csa_Jw_sigma_noe_grad   =  0 
 235  # 
 236  #            csa_Jw_sigma_noe_hess   =  0 
 237  # 
 238  # 
 239  #        Rex components 
 240  #        ~~~~~~~~~~~~~~ 
 241  # 
 242  #            rex_sigma_noe_func      =  0 
 243  # 
 244  #            rex_sigma_noe_grad      =  0 
 245  # 
 246  #            rex_sigma_noe_hess      =  0 
 247  # 
 248   
 249  from math import pi 
 250  from Numeric import Float64, zeros 
 251   
 252   
 253  # The main functions for the calculation of the Ri components. 
 254  ############################################################## 
 255   
 256  # These functions are duplicated many times for all combinations of Rex, bond length, and CSA as model parameters 
 257  # to make the code more efficient. 
 258   
 259  # Ri. 

 260 -def ri_comps(data, params): 

 261      """Calculate the ri function components. 
 262   
 263      Calculated: 
 264          Dipolar J(w) components. 
 265          CSA J(w) components. 
 266      Pre-calculated: 
 267          Rex constant components. 
 268          Dipolar constant components. 
 269          CSA constant components. 
 270      """ 
 271   
 272      # Loop over the relaxation values. 
 273      for i in xrange(data.num_ri): 
 274          # Dipolar J(w) components 
 275          data.dip_jw_comps_func[i] = data.create_dip_jw_func[i](data.jw, data.remap_table[i]) 
 276   
 277          # CSA J(w) components. 
 278          if data.create_csa_jw_func[i]: 
 279              data.csa_jw_comps_func[i] = data.create_csa_jw_func[i](data.jw, data.remap_table[i]) 

 280   
 281   
 282  # Ri (Rex). 

 283 -def ri_comps_rex(data, params): 

 284      """Calculate the ri function components. 
 285   
 286      Calculated: 
 287          Dipolar J(w) components. 
 288          CSA J(w) components. 
 289          Rex constant components. 
 290      Pre-calculated: 
 291          Dipolar constant components. 
 292          CSA constant components. 
 293      """ 
 294   
 295      # Loop over the relaxation values. 
 296      for i in xrange(data.num_ri): 
 297          # Dipolar J(w) components 
 298          data.dip_jw_comps_func[i] = data.create_dip_jw_func[i](data.jw, data.remap_table[i]) 
 299   
 300          # CSA J(w) components. 
 301          if data.create_csa_jw_func[i]: 
 302              data.csa_jw_comps_func[i] = data.create_csa_jw_func[i](data.jw, data.remap_table[i]) 
 303   
 304          # Rex components 
 305          if data.create_rex_func[i]: 
 306              data.rex_comps_func[i] = data.create_rex_func[i](params[data.rex_i], data.frq[data.remap_table[i]]) 

 307   
 308   
 309  # Ri (Bond length). 

 310 -def ri_comps_r(data, params): 

 311      """Calculate the ri function components. 
 312   
 313      Calculated: 
 314          Dipolar constant components. 
 315          Dipolar J(w) components. 
 316          CSA J(w) components. 
 317      Pre-calculated: 
 318          Rex constant components. 
 319          CSA constant components. 
 320      """ 
 321   
 322      # Dipolar constant function value. 
 323      comp_dip_const_func(data, params[data.r_i]) 
 324   
 325      # Loop over the relaxation values. 
 326      for i in xrange(data.num_ri): 
 327          # Dipolar constant components. 
 328          data.dip_comps_func[i] = data.dip_const_func 
 329          if data.create_dip_func[i]: 
 330              data.dip_comps_func[i] = data.create_dip_func[i](data.dip_const_func) 
 331   
 332          # Dipolar J(w) components 
 333          data.dip_jw_comps_func[i] = data.create_dip_jw_func[i](data.jw, data.remap_table[i]) 
 334   
 335          # CSA J(w) components. 
 336          if data.create_csa_jw_func[i]: 
 337              data.csa_jw_comps_func[i] = data.create_csa_jw_func[i](data.jw, data.remap_table[i]) 

 338   
 339   
 340  # Ri (CSA). 

 341 -def ri_comps_csa(data, params): 

 342      """Calculate the ri function components. 
 343   
 344      Calculated: 
 345          Dipolar J(w) components. 
 346          CSA constant components. 
 347          CSA J(w) components. 
 348      Pre-calculated: 
 349          Rex constant components. 
 350          Dipolar constant components. 
 351      """ 
 352   
 353      # CSA constant function value. 
 354      comp_csa_const_func(data, params[data.csa_i]) 
 355   
 356      # Loop over the relaxation values. 
 357      for i in xrange(data.num_ri): 
 358          # Dipolar J(w) components 
 359          data.dip_jw_comps_func[i] = data.create_dip_jw_func[i](data.jw, data.remap_table[i]) 
 360   
 361          # CSA constant components. 
 362          if data.create_csa_func[i]: 
 363              data.csa_comps_func[i] = data.create_csa_func[i](data.csa_const_func[data.remap_table[i]]) 
 364   
 365          # CSA J(w) components. 
 366          if data.create_csa_jw_func[i]: 
 367              data.csa_jw_comps_func[i] = data.create_csa_jw_func[i](data.jw, data.remap_table[i]) 

 368   
 369   
 370  # Ri (Bond length, CSA). 

 371 -def ri_comps_r_csa(data, params): 

 372      """Calculate the ri function components. 
 373   
 374      Calculated: 
 375          Dipolar constant components. 
 376          Dipolar J(w) components. 
 377          CSA constant components. 
 378          CSA J(w) components. 
 379      Pre-calculated: 
 380          Rex constant components. 
 381      """ 
 382   
 383      # Dipolar constant function value. 
 384      comp_dip_const_func(data, params[data.r_i]) 
 385   
 386      # CSA constant function value. 
 387      comp_csa_const_func(data, params[data.csa_i]) 
 388   
 389      # Loop over the relaxation values. 
 390      for i in xrange(data.num_ri): 
 391          # Dipolar constant components. 
 392          data.dip_comps_func[i] = data.dip_const_func 
 393          if data.create_dip_func[i]: 
 394              data.dip_comps_func[i] = data.create_dip_func[i](data.dip_const_func) 
 395   
 396          # Dipolar J(w) components 
 397          data.dip_jw_comps_func[i] = data.create_dip_jw_func[i](data.jw, data.remap_table[i]) 
 398   
 399          # CSA constant components. 
 400          if data.create_csa_func[i]: 
 401              data.csa_comps_func[i] = data.create_csa_func[i](data.csa_const_func[data.remap_table[i]]) 
 402   
 403          # CSA J(w) components. 
 404          if data.create_csa_jw_func[i]: 
 405              data.csa_jw_comps_func[i] = data.create_csa_jw_func[i](data.jw, data.remap_table[i]) 

 406   
 407   
 408  # Ri (Bond length, Rex). 

 409 -def ri_comps_r_rex(data, params): 

 410      """Calculate the ri function components. 
 411   
 412      Calculated: 
 413          Dipolar constant components. 
 414          Dipolar J(w) components. 
 415          CSA J(w) components. 
 416          Rex constant components. 
 417      Pre-calculated: 
 418          CSA constant components. 
 419      """ 
 420   
 421      # Dipolar constant function value. 
 422      comp_dip_const_func(data, params[data.r_i]) 
 423   
 424      # Loop over the relaxation values. 
 425      for i in xrange(data.num_ri): 
 426          # Dipolar constant components. 
 427          data.dip_comps_func[i] = data.dip_const_func 
 428          if data.create_dip_func[i]: 
 429              data.dip_comps_func[i] = data.create_dip_func[i](data.dip_const_func) 
 430   
 431          # Dipolar J(w) components 
 432          data.dip_jw_comps_func[i] = data.create_dip_jw_func[i](data.jw, data.remap_table[i]) 
 433   
 434          # CSA J(w) components. 
 435          if data.create_csa_jw_func[i]: 
 436              data.csa_jw_comps_func[i] = data.create_csa_jw_func[i](data.jw, data.remap_table[i]) 
 437   
 438          # Rex components 
 439          if data.create_rex_func[i]: 
 440              data.rex_comps_func[i] = data.create_rex_func[i](params[data.rex_i], data.frq[data.remap_table[i]]) 

 441   
 442   
 443  # Ri (CSA, Rex). 

 444 -def ri_comps_csa_rex(data, params): 

 445      """Calculate the ri function components. 
 446   
 447      Calculated: 
 448          Dipolar J(w) components. 
 449          CSA constant components. 
 450          CSA J(w) components. 
 451          Rex constant components. 
 452      Pre-calculated: 
 453          Dipolar constant components. 
 454      """ 
 455   
 456      # CSA constant function value. 
 457      comp_csa_const_func(data, params[data.csa_i]) 
 458   
 459      # Loop over the relaxation values. 
 460      for i in xrange(data.num_ri): 
 461          # Dipolar J(w) components 
 462          data.dip_jw_comps_func[i] = data.create_dip_jw_func[i](data.jw, data.remap_table[i]) 
 463   
 464          # CSA constant components. 
 465          if data.create_csa_func[i]: 
 466              data.csa_comps_func[i] = data.create_csa_func[i](data.csa_const_func[data.remap_table[i]]) 
 467   
 468          # CSA J(w) components. 
 469          if data.create_csa_jw_func[i]: 
 470              data.csa_jw_comps_func[i] = data.create_csa_jw_func[i](data.jw, data.remap_table[i]) 
 471   
 472          # Rex components 
 473          if data.create_rex_func[i]: 
 474              data.rex_comps_func[i] = data.create_rex_func[i](params[data.rex_i], data.frq[data.remap_table[i]]) 

 475   
 476   
 477  # Ri (Bond length, CSA, Rex). 

 478 -def ri_comps_r_csa_rex(data, params): 

 479      """Calculate the ri function components. 
 480   
 481      Calculated: 
 482          Dipolar constant components. 
 483          Dipolar J(w) components. 
 484          CSA constant components. 
 485          CSA J(w) components. 
 486          Rex constant components. 
 487      Pre-calculated: 
 488          None. 
 489      """ 
 490   
 491      # Dipolar constant function value. 
 492      comp_dip_const_func(data, params[data.r_i]) 
 493   
 494      # CSA constant function value. 
 495      comp_csa_const_func(data, params[data.csa_i]) 
 496   
 497      # Loop over the relaxation values. 
 498      for i in xrange(data.num_ri): 
 499          # Dipolar constant components. 
 500          data.dip_comps_func[i] = data.dip_const_func 
 501          if data.create_dip_func[i]: 
 502              data.dip_comps_func[i] = data.create_dip_func[i](data.dip_const_func) 
 503   
 504          # Dipolar J(w) components 
 505          data.dip_jw_comps_func[i] = data.create_dip_jw_func[i](data.jw, data.remap_table[i]) 
 506   
 507          # CSA constant components. 
 508          if data.create_csa_func[i]: 
 509              data.csa_comps_func[i] = data.create_csa_func[i](data.csa_const_func[data.remap_table[i]]) 
 510   
 511          # CSA J(w) components. 
 512          if data.create_csa_jw_func[i]: 
 513              data.csa_jw_comps_func[i] = data.create_csa_jw_func[i](data.jw, data.remap_table[i]) 
 514   
 515          # Rex components 
 516          if data.create_rex_func[i]: 
 517              data.rex_comps_func[i] = data.create_rex_func[i](params[data.rex_i], data.frq[data.remap_table[i]]) 

 518   
 519   
 520  # R1 comps. 

 521 -def r1_comps(data, i, params): 

 522      """Calculate the r1 function components.""" 
 523   
 524      # Dipolar constant function value. 
 525      if data.r_i: 
 526          comp_dip_const_func(data, params[data.r_i]) 
 527   
 528      # CSA constant function value. 
 529      if data.csa_i: 
 530          comp_csa_const_func(data, params[data.csa_i]) 
 531   
 532      # Dipolar constant components. 
 533      data.dip_comps_func[i] = data.dip_const_func 
 534   
 535      # Dipolar J(w) components 
 536      data.dip_jw_comps_func[i] = comp_r1_dip_jw(data.jw, data.remap_table[i]) 
 537   
 538      # CSA constant components. 
 539      data.csa_comps_func[i] = data.csa_const_func[data.remap_table[i]] 
 540   
 541      # CSA J(w) components. 
 542      data.csa_jw_comps_func[i] = comp_r1_csa_jw(data.jw, data.remap_table[i]) 

 543   
 544   
 545   
 546  # The main functions for the calculation of the dRi components. 
 547  ############################################################### 
 548   
 549  # These functions are duplicated many times for all combinations of Rex, bond length, and CSA as model parameters 
 550  # to make the code more efficient. 
 551   
 552   
 553  # dRi. 

 554 -def dri_comps(data, params): 

 555      """Calculate the dri gradient components. 
 556   
 557      Calculated: 
 558          Dipolar J(w) components. 
 559          CSA J(w) components. 
 560      Pre-calculated: 
 561          Rex constant components. 
 562          Dipolar constant components. 
 563          CSA constant components. 
 564      """ 
 565   
 566      # Loop over the relaxation values. 
 567      for i in xrange(data.num_ri): 
 568          # Dipolar J(w) components 
 569          data.dip_jw_comps_grad[i] = data.create_dip_jw_grad[i](data.djw, data.remap_table[i]) 
 570   
 571          # CSA J(w) components. 
 572          if data.create_csa_jw_grad[i]: 
 573              data.csa_jw_comps_grad[i] = data.create_csa_jw_grad[i](data.djw, data.remap_table[i]) 

 574   
 575   
 576  # dRi (Rex). 

 577 -def dri_comps_rex(data, params): 

 578      """Calculate the dri gradient components. 
 579   
 580      Calculated: 
 581          Dipolar J(w) components. 
 582          CSA J(w) components. 
 583          Rex constant components. 
 584      Pre-calculated: 
 585          Dipolar constant components. 
 586          CSA constant components. 
 587      """ 
 588   
 589      # Loop over the relaxation values. 
 590      for i in xrange(data.num_ri): 
 591          # Dipolar J(w) components 
 592          data.dip_jw_comps_grad[i] = data.create_dip_jw_grad[i](data.djw, data.remap_table[i]) 
 593   
 594          # CSA J(w) components. 
 595          if data.create_csa_jw_grad[i]: 
 596              data.csa_jw_comps_grad[i] = data.create_csa_jw_grad[i](data.djw, data.remap_table[i]) 
 597   
 598          # Rex components 
 599          if data.create_rex_grad[i]: 
 600              data.rex_comps_grad[i] = data.create_rex_grad[i](data.frq[data.remap_table[i]]) 

 601   
 602   
 603  # dRi (Bond length). 

 604 -def dri_comps_r(data, params): 

 605      """Calculate the dri gradient components. 
 606   
 607      Calculated: 
 608          Dipolar constant components. 
 609          Dipolar J(w) components. 
 610          CSA J(w) components. 
 611      Pre-calculated: 
 612          Rex constant components. 
 613          CSA constant components. 
 614      """ 
 615   
 616      # Dipolar constant gradient value. 
 617      comp_dip_const_grad(data, params[data.r_i]) 
 618   
 619      # Loop over the relaxation values. 
 620      for i in xrange(data.num_ri): 
 621          # Dipolar constant components. 
 622          data.dip_comps_grad[i] = data.dip_const_grad 
 623          if data.create_dip_grad[i]: 
 624              data.dip_comps_grad[i] = data.create_dip_grad[i](data.dip_const_grad) 
 625   
 626          # Dipolar J(w) components 
 627          data.dip_jw_comps_grad[i] = data.create_dip_jw_grad[i](data.djw, data.remap_table[i]) 
 628   
 629          # CSA J(w) components. 
 630          if data.create_csa_jw_grad[i]: 
 631              data.csa_jw_comps_grad[i] = data.create_csa_jw_grad[i](data.djw, data.remap_table[i]) 

 632   
 633   
 634  # dRi (CSA). 

 635 -def dri_comps_csa(data, params): 

 636      """Calculate the dri gradient components. 
 637   
 638      Calculated: 
 639          Dipolar J(w) components. 
 640          CSA constant components. 
 641          CSA J(w) components. 
 642      Pre-calculated: 
 643          Rex constant components. 
 644          Dipolar constant components. 
 645      """ 
 646   
 647      # CSA constant gradient value. 
 648      comp_csa_const_grad(data, params[data.csa_i]) 
 649   
 650      # Loop over the relaxation values. 
 651      for i in xrange(data.num_ri): 
 652          # Dipolar J(w) components 
 653          data.dip_jw_comps_grad[i] = data.create_dip_jw_grad[i](data.djw, data.remap_table[i]) 
 654   
 655          # CSA constant components. 
 656          if data.create_csa_grad[i]: 
 657              data.csa_comps_grad[i] = data.create_csa_grad[i](data.csa_const_grad[data.remap_table[i]]) 
 658   
 659          # CSA J(w) components. 
 660          if data.create_csa_jw_grad[i]: 
 661              data.csa_jw_comps_grad[i] = data.create_csa_jw_grad[i](data.djw, data.remap_table[i]) 

 662   
 663   
 664  # dRi (Bond length, CSA). 

 665 -def dri_comps_r_csa(data, params): 

 666      """Calculate the dri gradient components. 
 667   
 668      Calculated: 
 669          Dipolar constant components. 
 670          Dipolar J(w) components. 
 671          CSA constant components. 
 672          CSA J(w) components. 
 673      Pre-calculated: 
 674          Rex constant components. 
 675      """ 
 676   
 677      # Dipolar constant gradient value. 
 678      comp_dip_const_grad(data, params[data.r_i]) 
 679   
 680      # CSA constant gradient value. 
 681      comp_csa_const_grad(data, params[data.csa_i]) 
 682   
 683      # Loop over the relaxation values. 
 684      for i in xrange(data.num_ri): 
 685          # Dipolar constant components. 
 686          data.dip_comps_grad[i] = data.dip_const_grad 
 687          if data.create_dip_grad[i]: 
 688              data.dip_comps_grad[i] = data.create_dip_grad[i](data.dip_const_grad) 
 689   
 690          # Dipolar J(w) components 
 691          data.dip_jw_comps_grad[i] = data.create_dip_jw_grad[i](data.djw, data.remap_table[i]) 
 692   
 693          # CSA constant components. 
 694          if data.create_csa_grad[i]: 
 695              data.csa_comps_grad[i] = data.create_csa_grad[i](data.csa_const_grad[data.remap_table[i]]) 
 696   
 697          # CSA J(w) components. 
 698          if data.create_csa_jw_grad[i]: 
 699              data.csa_jw_comps_grad[i] = data.create_csa_jw_grad[i](data.djw, data.remap_table[i]) 

 700   
 701   
 702  # dRi (Bond length, Rex). 

 703 -def dri_comps_r_rex(data, params): 

 704      """Calculate the dri gradient components. 
 705   
 706      Calculated: 
 707          Dipolar constant components. 
 708          Dipolar J(w) components. 
 709          CSA J(w) components. 
 710          Rex constant components. 
 711      Pre-calculated: 
 712          CSA constant components. 
 713      """ 
 714   
 715      # Dipolar constant gradient value. 
 716      comp_dip_const_grad(data, params[data.r_i]) 
 717   
 718      # Loop over the relaxation values. 
 719      for i in xrange(data.num_ri): 
 720          # Dipolar constant components. 
 721          data.dip_comps_grad[i] = data.dip_const_grad 
 722          if data.create_dip_grad[i]: 
 723              data.dip_comps_grad[i] = data.create_dip_grad[i](data.dip_const_grad) 
 724   
 725          # Dipolar J(w) components 
 726          data.dip_jw_comps_grad[i] = data.create_dip_jw_grad[i](data.djw, data.remap_table[i]) 
 727   
 728          # CSA J(w) components. 
 729          if data.create_csa_jw_grad[i]: 
 730              data.csa_jw_comps_grad[i] = data.create_csa_jw_grad[i](data.djw, data.remap_table[i]) 
 731   
 732          # Rex components 
 733          if data.create_rex_grad[i]: 
 734              data.rex_comps_grad[i] = data.create_rex_grad[i](data.frq[data.remap_table[i]]) 

 735   
 736   
 737  # dRi (CSA, Rex). 

 738 -def dri_comps_csa_rex(data, params): 

 739      """Calculate the dri gradient components. 
 740   
 741      Calculated: 
 742          Dipolar J(w) components. 
 743          CSA constant components. 
 744          CSA J(w) components. 
 745          Rex constant components. 
 746      Pre-calculated: 
 747          Dipolar constant components. 
 748      """ 
 749   
 750      # CSA constant gradient value. 
 751      comp_csa_const_grad(data, params[data.csa_i]) 
 752   
 753      # Loop over the relaxation values. 
 754      for i in xrange(data.num_ri): 
 755          # Dipolar J(w) components 
 756          data.dip_jw_comps_grad[i] = data.create_dip_jw_grad[i](data.djw, data.remap_table[i]) 
 757   
 758          # CSA constant components. 
 759          if data.create_csa_grad[i]: 
 760              data.csa_comps_grad[i] = data.create_csa_grad[i](data.csa_const_grad[data.remap_table[i]]) 
 761   
 762          # CSA J(w) components. 
 763          if data.create_csa_jw_grad[i]: 
 764              data.csa_jw_comps_grad[i] = data.create_csa_jw_grad[i](data.djw, data.remap_table[i]) 
 765   
 766          # Rex components 
 767          if data.create_rex_grad[i]: 
 768              data.rex_comps_grad[i] = data.create_rex_grad[i](data.frq[data.remap_table[i]]) 

 769   
 770   
 771  # dRi (Bond length, CSA, Rex). 

 772 -def dri_comps_r_csa_rex(data, params): 

 773      """Calculate the dri gradient components. 
 774   
 775      Calculated: 
 776          Dipolar constant components. 
 777          Dipolar J(w) components. 
 778          CSA constant components. 
 779          CSA J(w) components. 
 780          Rex constant components. 
 781      Pre-calculated: 
 782          None. 
 783      """ 
 784   
 785      # Dipolar constant gradient value. 
 786      comp_dip_const_grad(data, params[data.r_i]) 
 787   
 788      # CSA constant gradient value. 
 789      comp_csa_const_grad(data, params[data.csa_i]) 
 790   
 791      # Loop over the relaxation values. 
 792      for i in xrange(data.num_ri): 
 793          # Dipolar constant components. 
 794          data.dip_comps_grad[i] = data.dip_const_grad 
 795          if data.create_dip_grad[i]: 
 796              data.dip_comps_grad[i] = data.create_dip_grad[i](data.dip_const_grad) 
 797   
 798          # Dipolar J(w) components 
 799          data.dip_jw_comps_grad[i] = data.create_dip_jw_grad[i](data.djw, data.remap_table[i]) 
 800   
 801          # CSA constant components. 
 802          if data.create_csa_grad[i]: 
 803              data.csa_comps_grad[i] = data.create_csa_grad[i](data.csa_const_grad[data.remap_table[i]]) 
 804   
 805          # CSA J(w) components. 
 806          if data.create_csa_jw_grad[i]: 
 807              data.csa_jw_comps_grad[i] = data.create_csa_jw_grad[i](data.djw, data.remap_table[i]) 
 808   
 809          # Rex components 
 810          if data.create_rex_grad[i]: 
 811              data.rex_comps_grad[i] = data.create_rex_grad[i](data.frq[data.remap_table[i]]) 

 812   
 813   
 814  # dR1 comps. 

 815 -def dr1_comps(data, i, params): 

 816      """Calculate the dr1 gradient components.""" 
 817   
 818      # Dipolar constant gradient value. 
 819      if data.r_i: 
 820          comp_dip_const_grad(data, params[data.r_i]) 
 821   
 822      # CSA constant gradient value. 
 823      if data.csa_i: 
 824          comp_csa_const_grad(data, params[data.csa_i]) 
 825   
 826      # Dipolar constant components. 
 827      data.dip_comps_grad[i] = data.dip_const_grad 
 828   
 829      # Dipolar J(w) components 
 830      data.dip_jw_comps_grad[i] = comp_r1_dip_jw(data.djw, data.remap_table[i]) 
 831   
 832      # CSA constant components. 
 833      data.csa_comps_grad[i] = data.csa_const_grad[data.remap_table[i]] 
 834   
 835      # CSA J(w) components. 
 836      data.csa_jw_comps_grad[i] = comp_r1_csa_jw(data.djw, data.remap_table[i]) 

 837   
 838   
 839  # The main functions for the calculation of the d2Ri components. 
 840  ################################################################ 
 841   
 842  # These functions are duplicated many times for all combinations of Rex, bond length, and CSA as model parameters 
 843  # to make the code more efficient. 
 844   
 845   
 846  # d2Ri. 

 847 -def d2ri_comps(data, params): 

 848      """Calculate the d2ri Hessian components. 
 849   
 850      Calculated: 
 851          Dipolar J(w) components. 
 852          CSA J(w) components. 
 853      Pre-calculated: 
 854          Rex constant components. 
 855          Dipolar constant components. 
 856          CSA constant components. 
 857      """ 
 858   
 859      # Loop over the relaxation values. 
 860      for i in xrange(data.num_ri): 
 861          # Dipolar J(w) components 
 862          data.dip_jw_comps_hess[i] = data.create_dip_jw_hess[i](data.d2jw, data.remap_table[i]) 
 863   
 864          # CSA J(w) components. 
 865          if data.create_csa_jw_hess[i]: 
 866              data.csa_jw_comps_hess[i] = data.create_csa_jw_hess[i](data.d2jw, data.remap_table[i]) 

 867   
 868   
 869  # d2Ri (Bond length). 

 870 -def d2ri_comps_r(data, params): 

 871      """Calculate the d2ri Hessian components. 
 872   
 873      Calculated: 
 874          Dipolar constant components. 
 875          Dipolar J(w) components. 
 876          CSA J(w) components. 
 877      Pre-calculated: 
 878          Rex constant components. 
 879          CSA constant components. 
 880      """ 
 881   
 882      # Dipolar constant Hessian value. 
 883      comp_dip_const_hess(data, params[data.r_i]) 
 884   
 885      # Loop over the relaxation values. 
 886      for i in xrange(data.num_ri): 
 887          # Dipolar constant components. 
 888          data.dip_comps_hess[i] = data.dip_const_hess 
 889          if data.create_dip_hess[i]: 
 890              data.dip_comps_hess[i] = data.create_dip_hess[i](data.dip_const_hess) 
 891   
 892          # Dipolar J(w) components 
 893          data.dip_jw_comps_hess[i] = data.create_dip_jw_hess[i](data.d2jw, data.remap_table[i]) 
 894   
 895          # CSA J(w) components. 
 896          if data.create_csa_jw_hess[i]: 
 897              data.csa_jw_comps_hess[i] = data.create_csa_jw_hess[i](data.d2jw, data.remap_table[i]) 

 898   
 899   
 900  # d2Ri (CSA). 

 901 -def d2ri_comps_csa(data, params): 

 902      """Calculate the d2ri Hessian components. 
 903   
 904      Calculated: 
 905          Dipolar J(w) components. 
 906          CSA constant components. 
 907          CSA J(w) components. 
 908      Pre-calculated: 
 909          Rex constant components. 
 910          Dipolar constant components. 
 911      """ 
 912   
 913      # CSA constant Hessian value. 
 914      comp_csa_const_hess(data, params) 
 915   
 916      # Loop over the relaxation values. 
 917      for i in xrange(data.num_ri): 
 918          # Dipolar J(w) components 
 919          data.dip_jw_comps_hess[i] = data.create_dip_jw_hess[i](data.d2jw, data.remap_table[i]) 
 920   
 921          # CSA constant components. 
 922          if data.create_csa_hess[i]: 
 923              data.csa_comps_hess[i] = data.create_csa_hess[i](data.csa_const_hess[data.remap_table[i]]) 
 924   
 925          # CSA J(w) components. 
 926          if data.create_csa_jw_hess[i]: 
 927              data.csa_jw_comps_hess[i] = data.create_csa_jw_hess[i](data.d2jw, data.remap_table[i]) 

 928   
 929   
 930  # d2Ri (Bond length, CSA). 

 931 -def d2ri_comps_r_csa(data, params): 

 932      """Calculate the d2ri Hessian components. 
 933   
 934      Calculated: 
 935          Dipolar constant components. 
 936          Dipolar J(w) components. 
 937          CSA constant components. 
 938          CSA J(w) components. 
 939      Pre-calculated: 
 940          Rex constant components. 
 941      """ 
 942   
 943      # Dipolar constant Hessian value. 
 944      comp_dip_const_hess(data, params[data.r_i]) 
 945   
 946      # CSA constant Hessian value. 
 947      comp_csa_const_hess(data, params) 
 948   
 949      # Loop over the relaxation values. 
 950      for i in xrange(data.num_ri): 
 951          # Dipolar constant components. 
 952          data.dip_comps_hess[i] = data.dip_const_hess 
 953          if data.create_dip_hess[i]: 
 954              data.dip_comps_hess[i] = data.create_dip_hess[i](data.dip_const_hess) 
 955   
 956          # Dipolar J(w) components 
 957          data.dip_jw_comps_hess[i] = data.create_dip_jw_hess[i](data.d2jw, data.remap_table[i]) 
 958   
 959          # CSA constant components. 
 960          if data.create_csa_hess[i]: 
 961              data.csa_comps_hess[i] = data.create_csa_hess[i](data.csa_const_hess[data.remap_table[i]]) 
 962   
 963          # CSA J(w) components. 
 964          if data.create_csa_jw_hess[i]: 
 965              data.csa_jw_comps_hess[i] = data.create_csa_jw_hess[i](data.d2jw, data.remap_table[i]) 

 966   
 967   
 968  # d2R1 comps. 

 969 -def d2r1_comps(data, i, params): 

 970      """Calculate the d2ri Hessian components.""" 
 971   
 972      # Dipolar constant gradient value. 
 973      if data.r_i: 
 974          comp_dip_const_hess(data, params[data.r_i]) 
 975   
 976      # CSA constant gradient value. 
 977      if data.csa_i: 
 978          comp_csa_const_hess(data, params) 
 979   
 980      # Dipolar constant components. 
 981      data.dip_comps_hess[i] = data.dip_const_hess 
 982   
 983      # Dipolar J(w) components 
 984      data.dip_jw_comps_hess[i] = comp_r1_dip_jw(data.d2jw, data.remap_table[i]) 
 985   
 986      # CSA constant components. 
 987      data.csa_comps_hess[i] = data.csa_const_hess[data.remap_table[i]] 
 988   
 989      # CSA J(w) components. 
 990      data.csa_jw_comps_hess[i] = comp_r1_csa_jw(data.d2jw, data.remap_table[i]) 

 991   
 992   
 993   
 994  # Functions to calculate the invariant part of the dipolar and CSA constants. 
 995  ############################################################################# 
 996   
 997   
 998  # Dipolar. 

 999 -def calc_fixed_dip(data): 

1000      """Calculate the fixed component of the dipolar constant. 
1001   
1002                          / mu0  \ 2 
1003      dip_const_fixed  =  | ---- |  . (gH.gN.h_bar)**2 
1004                          \ 4.pi / 
1005      """ 
1006   
1007      data.dip_const_fixed = ((data.mu0 / (4.0*pi)) * data.h_bar * data.gh * data.gx) ** 2 

1008   
1009   
1010  # CSA. 

1011 -def calc_fixed_csa(data): 

1012      """Calculate the fixed component of the CSA constants. 
1013   
1014                          wN**2 
1015      csa_const_fixed  =  ----- 
1016                            3 
1017      """ 
1018   
1019      for j in xrange(data.num_frq): 
1020          data.csa_const_fixed[j] = data.frq_sqrd_list[j, 1] / 3.0 

1021   
1022   
1023   
1024  # Functions to calculate the dipolar constant values, gradients, and Hessians. 
1025  ############################################################################## 
1026   
1027   
1028  # Function. 

1029 -def comp_dip_const_func(data, bond_length): 

1030      """Calculate the dipolar constant. 
1031   
1032      Dipolar constant 
1033      ~~~~~~~~~~~~~~~~ 
1034   
1035                             1   / mu0  \ 2  (gH.gN.h_bar)**2 
1036          dip_const_func  =  - . | ---- |  . ---------------- 
1037                             4   \ 4.pi /         <r**6> 
1038      """ 
1039   
1040      if bond_length == 0.0: 
1041          data.dip_const_func = 1e99 
1042      else: 
1043          data.dip_const_func = 0.25 * data.dip_const_fixed * bond_length**-6 

1044   
1045   
1046  # Gradient. 

1047 -def comp_dip_const_grad(data, bond_length): 

1048      """Calculate the derivative of the dipolar constant. 
1049   
1050      Dipolar constant gradient 
1051      ~~~~~~~~~~~~~~~~~~~~~~~~~ 
1052   
1053                               3   / mu0  \ 2  (gH.gN.h_bar)**2 
1054          dip_const_grad  =  - - . | ---- |  . ---------------- 
1055                               2   \ 4.pi /         <r**7> 
1056      """ 
1057   
1058      if bond_length == 0.0: 
1059          data.dip_const_grad = 1e99 
1060      else: 
1061          data.dip_const_grad = -1.5 * data.dip_const_fixed * bond_length**-7 

1062   
1063   
1064  # Hessian. 

1065 -def comp_dip_const_hess(data, bond_length): 

1066      """Calculate the second derivative of the dipolar constant. 
1067   
1068      Dipolar constant Hessian 
1069      ~~~~~~~~~~~~~~~~~~~~~~~~ 
1070   
1071                             21   / mu0  \ 2  (gH.gN.h_bar)**2 
1072          dip_const_hess  =  -- . | ---- |  . ---------------- 
1073                             2    \ 4.pi /         <r**8> 
1074      """ 
1075   
1076      if bond_length == 0.0: 
1077          data.dip_const_hess = 1e99 
1078      else: 
1079          data.dip_const_hess = 10.5 * data.dip_const_fixed * bond_length**-8 

1080   
1081   
1082   
1083  # Functions to calculate the CSA constant values, gradients, and Hessians. 
1084  ########################################################################## 
1085   
1086   
1087  # Function. 

1088 -def comp_csa_const_func(data, csa): 

1089      """Calculate the CSA constant. 
1090   
1091      CSA constant 
1092      ~~~~~~~~~~~~ 
1093   
1094                             (wN.csa)**2 
1095          csa_const_func  =  ----------- 
1096                                  3 
1097      """ 
1098   
1099      for i in xrange(data.num_frq): 
1100          data.csa_const_func[i] = data.csa_const_fixed[i] * csa**2 

1101   
1102   
1103  # Gradient. 

1104 -def comp_csa_const_grad(data, csa): 

1105      """Calculate the derivative of the CSA constant. 
1106   
1107      CSA constant gradient 
1108      ~~~~~~~~~~~~~~~~~~~~~ 
1109   
1110                             2.wN**2.csa 
1111          csa_const_grad  =  ----------- 
1112                                  3 
1113      """ 
1114   
1115      for i in xrange(data.num_frq): 
1116          data.csa_const_grad[i] = 2.0 * data.csa_const_fixed[i] * csa 

1117   
1118   
1119  # Hessian. 

1120 -def comp_csa_const_hess(data, params): 

1121      """Calculate the second derivative of the CSA constant. 
1122   
1123      CSA constant Hessian 
1124      ~~~~~~~~~~~~~~~~~~~~ 
1125   
1126                             2.wN**2 
1127          csa_const_hess  =  ------- 
1128                                3 
1129      """ 
1130   
1131      for i in xrange(data.num_frq): 
1132          data.csa_const_hess[i] = 2.0 * data.csa_const_fixed[i] 

1133   
1134   
1135   
1136  # Functions to calculate the Rex constant values and gradients. 
1137  ############################################################### 
1138   
1139   
1140  # Function. 

1141 -def comp_rex_const_func(rhoex, frq): 

1142      """Calculate the Rex value. 
1143   
1144      Rex constant 
1145      ~~~~~~~~~~~~ 
1146   
1147          rex_const_func  =  rhoex * wH**2 
1148      """ 
1149   
1150      return rhoex * (2.0 * pi * frq) ** 2 

1151   
1152   
1153  # Gradient. 

1154 -def comp_rex_const_grad(frq): 

1155      """Calculate the Rex gradient. 
1156   
1157      Rex gradient 
1158      ~~~~~~~~~~~~ 
1159   
1160          rex_const_grad  =  wH**2 
1161      """ 
1162   
1163      return (2.0 * pi * frq) ** 2 

1164   
1165   
1166   
1167  # Functions to calculate the dipolar constant components. 
1168  ######################################################### 
1169   
1170   

1171 -def comp_r2_dip_const(dip_const_data): 

1172      """Calculate the R1 dipolar constant components. 
1173   
1174      dip_const_func / 2 
1175   
1176      dip_const_grad / 2 
1177   
1178      dip_const_hess / 2 
1179      """ 
1180   
1181      return dip_const_data / 2.0 

1182   
1183   
1184   
1185  # Functions to calculate the CSA constant components. 
1186  ##################################################### 
1187   
1188  # sigma_noe has no CSA components! 
1189   

1190 -def comp_r1_csa_const(csa_const_data): 

1191      """Calculate the R1 CSA constant components. 
1192   
1193      csa_const_func 
1194   
1195      csa_const_grad 
1196   
1197      csa_const_hess 
1198      """ 
1199   
1200      return csa_const_data 

1201   
1202   

1203 -def comp_r2_csa_const(csa_const_data): 

1204      """Calculate the R2 CSA constant. components 
1205   
1206      csa_const_func / 6 
1207   
1208      csa_const_grad / 6 
1209   
1210      csa_const_hess / 6 
1211      """ 
1212   
1213      return csa_const_data / 6.0 

1214   
1215   
1216   
1217  # Functions to calculate the dipolar J(w) components. 
1218  ##################################################### 
1219   
1220   
1221  # R1. 

1222 -def comp_r1_dip_jw(jw_data, frq_num): 

1223      """Calculate the R1 dipolar J(w) components. 
1224   
1225      dip_Jw_R1_func  =  J(wH-wN) + 3J(wN) + 6J(wH+wN) 
1226   
1227                         dJ(wH-wN)         dJ(wN)         dJ(wH+wN) 
1228      dip_Jw_R1_grad  =  ---------  +  3 . ------  +  6 . --------- 
1229                            dJw             dJw              dJw 
1230   
1231                         d2J(wH-wN)          d2J(wN)          d2J(wH+wN) 
1232      dip_Jw_R1_hess  =  ----------  +  3 . ---------  +  6 . ---------- 
1233                         dJwi.dJwj          dJwi.dJwj         dJwi.dJwj 
1234      """ 
1235   
1236      return jw_data[frq_num, 2] + 3.0*jw_data[frq_num, 1] + 6.0*jw_data[frq_num, 4] 

1237   
1238   
1239  # R2. 

1240 -def comp_r2_dip_jw(jw_data, frq_num): 

1241      """Calculate the R2 dipolar J(w) components. 
1242   
1243      dip_Jw_R2_func  =  4J(0) + J(wH-wN) + 3J(wN) + 6J(wH) + 6J(wH+wN) 
1244   
1245                             dJ(0)     dJ(wH-wN)         dJ(wN)         dJ(wH)         dJ(wH+wN) 
1246      dip_Jw_R2_grad  =  4 . -----  +  ---------  +  3 . ------  +  6 . ------  +  6 . --------- 
1247                              dJw         dJw             dJw            dJw              dJw 
1248   
1249                               d2J(0)      d2J(wH-wN)          d2J(wN)           d2J(wH)          d2J(wH+wN) 
1250      dip_Jw_R2_hess  =  4 . ---------  +  ----------  +  3 . ---------  +  6 . ---------  +  6 . ---------- 
1251                             dJwi.dJwj     dJwi.dJwj          dJwi.dJwj         dJwi.dJwj         dJwi.dJwj 
1252      """ 
1253   
1254      return 4.0*jw_data[frq_num, 0] + jw_data[frq_num, 2] + 3.0*jw_data[frq_num, 1] + 6.0*jw_data[frq_num, 3] + 6.0*jw_data[frq_num, 4] 

1255   
1256   
1257  # sigma_noe. 

1258 -def comp_sigma_noe_dip_jw(jw_data, frq_num): 

1259      """Calculate the sigma_noe dipolar J(w) components. 
1260   
1261      dip_Jw_sigma_noe_func  =  6J(wH+wN) - J(wH-wN) 
1262   
1263                                    dJ(wH+wN)     dJ(wH-wN) 
1264      dip_Jw_sigma_noe_grad  =  6 . ---------  -  --------- 
1265                                       dJw           dJw 
1266   
1267                                    d2J(wH+wN)     d2J(wH-wN) 
1268      dip_Jw_sigma_noe_hess  =  6 . ----------  -  ---------- 
1269                                    dJwi.dJwj      dJwi.dJwj 
1270      """ 
1271   
1272      return 6.0*jw_data[frq_num, 4] - jw_data[frq_num, 2] 

1273   
1274   
1275   
1276  # Functions to calculate the CSA J(w) components. 
1277  ################################################# 
1278   
1279  # sigma_noe has no CSA J(w) components! 
1280   
1281  # R1. 

1282 -def comp_r1_csa_jw(jw_data, frq_num): 

1283      """Calculate the R1 CSA J(w) components. 
1284   
1285      csa_Jw_R1_func  =  J(wN) 
1286   
1287                         dJ(wN) 
1288      csa_Jw_R1_grad  =  ------ 
1289                          dJw 
1290   
1291                          d2J(wN) 
1292      csa_Jw_R1_hess  =  --------- 
1293                         dJwi.dJwj 
1294      """ 
1295   
1296      return jw_data[frq_num, 1] 

1297   
1298   
1299  # R2. 

1300 -def comp_r2_csa_jw(jw_data, frq_num): 

1301      """Calculate the R1 CSA J(w) components. 
1302   
1303      csa_Jw_R2_func  =  4J(0) + 3J(wN) 
1304   
1305                             dJ(0)         dJ(wN) 
1306      csa_Jw_R2_grad  =  4 . -----  +  3 . ------ 
1307                              dJw           dJw 
1308   
1309                               d2J(0)           d2J(wN) 
1310      csa_Jw_R2_hess  =  4 . ---------  +  3 . --------- 
1311                             dJwi.dJwj         dJwi.dJwj 
1312      """ 
1313   
1314      return 4.0*jw_data[frq_num, 0] + 3.0*jw_data[frq_num, 1] 

1315

   Trees       Indices       Help   
relax
Generated by Epydoc 3.0.1 on Wed Apr 10 13:58:34 2013 http://epydoc.sourceforge.net