Rosetta 3.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
DunbrackRotamer.cc
Go to the documentation of this file.
1 // -*- mode:c++;tab-width:2;indent-tabs-mode:t;show-trailing-whitespace:t;rm-trailing-spaces:t -*-
2 // vi: set ts=2 noet:
3 //
4 // (c) Copyright Rosetta Commons Member Institutions.
5 // (c) This file is part of the Rosetta software suite and is made available under license.
6 // (c) The Rosetta software is developed by the contributing members of the Rosetta Commons.
7 // (c) For more information, see http://www.rosettacommons.org. Questions about this can be
8 // (c) addressed to University of Washington UW TechTransfer, email: license@u.washington.edu.
9 
10 /// @file
11 /// @brief
12 /// @author
13 
14 
15 // Unit headers
16 #include <core/pack/dunbrack/DunbrackRotamer.hh>
17 
18 // Package headers
19 #include <core/pack/dunbrack/ChiSet.hh>
20 // AUTO-REMOVED #include <core/pack/dunbrack/RotamerLibrary.hh>
21 
22 // Project headers
23 // AUTO-REMOVED #include <core/conformation/Residue.hh>
24 // AUTO-REMOVED #include <core/conformation/ResidueFactory.hh>
25 
26 // AUTO-REMOVED #include <basic/database/open.hh>
27 
28 // AUTO-REMOVED #include <basic/options/option.hh>
29 
30 // AUTO-REMOVED #include <core/pack/task/PackerTask.hh>
31 // AUTO-REMOVED #include <core/pose/Pose.hh>
32 
33 // AUTO-REMOVED #include <basic/basic.hh>
34 #include <basic/interpolate.hh>
35 
36 // Numeric headers
37 // AUTO-REMOVED #include <numeric/xyz.functions.hh>
38 #include <numeric/constants.hh>
39 #include <numeric/angle.functions.hh>
40 #include <numeric/random/random.hh>
41 
42 // Utility headers
43 // AUTO-REMOVED #include <utility/LexicographicalIterator.hh>
44 // AUTO-REMOVED #include <utility/io/izstream.hh>
45 // AUTO-REMOVED #include <utility/io/ozstream.hh>
46 
47 // ObjexxFCL headers
48 // AUTO-REMOVED #include <ObjexxFCL/FArray1D.hh>
49 // AUTO-REMOVED #include <ObjexxFCL/format.hh>
50 
51 
52 #include <cmath>
53 #include <iostream>
54 // AUTO-REMOVED #include <fstream>
55 
56 #include <basic/Tracer.hh>
57 #include <basic/basic.hh>
58 
59 #include <core/chemical/ResidueType.hh>
60 #include <utility/vector1.hh>
61 
62 using basic::T;
63 using basic::Error;
64 using basic::Warning;
65 
66 static basic::Tracer TR("core.pack.dunbrack");
67 
68 namespace core {
69 namespace pack {
70 namespace dunbrack {
71 
72 /// @details Fun Fact: virtual destructor must still be defined even if it's abstract
73 RotamerBuildingData::~RotamerBuildingData() {}
74 
75 /// @brief Interpolate in a grid with the values, and second derivatives given, and
76 /// simultaneously evaluate the derivative. No option for working with periodic ranges.
77 /// Instead, make sure that interpolation doesn't need to span > 180 degrees.
78 void bicubic_interpolation(
79  Real v00, Real d2dx200, Real d2dy200, Real d4dx2y200,
80  Real v01, Real d2dx201, Real d2dy201, Real d4dx2y201,
81  Real v10, Real d2dx210, Real d2dy210, Real d4dx2y210,
82  Real v11, Real d2dx211, Real d2dy211, Real d4dx2y211,
83  Real dxp, // in the range [0..1) representing the distance to the left bin boundary
84  Real dyp, // in the range [0..1) representing the distance to the lower bin boundary
85  Real binwx, // the size of the bin witdh for x
86  Real binwy, // the size of the bin width for y
87  Real & val,
88  Real & dvaldx,
89  Real & dvaldy
90 )
91 {
92  //std::cout.precision(16);
93  //std::cout << " v00 " << v00 << " d2dx200 " << d2dx200 << " d2dy200 " << d2dy200 << " d4dx2y200 " << d4dx2y200 << std::endl;
94  //std::cout << " v01 " << v01 << " d2dx201 " << d2dx201 << " d2dy201 " << d2dy201 << " d4dx2y201 " << d4dx2y201 << std::endl;
95  //std::cout << " v10 " << v10 << " d2dx210 " << d2dx210 << " d2dy210 " << d2dy210 << " d4dx2y210 " << d4dx2y210 << std::endl;
96  //std::cout << " v11 " << v11 << " d2dx211 " << d2dx211 << " d2dy211 " << d2dy211 << " d4dx2y211 " << d4dx2y211 << std::endl;
97  //std::cout << " dxp " << dxp << std::endl;
98  //std::cout << " dyp " << dyp << std::endl;
99  //std::cout << " binwx " << binwx << std::endl;
100  //std::cout << " binwy " << binwy << std::endl;
101  //std::cout << std::endl;
102 
103  assert( dxp >= 0 && dxp < 1.0 );
104  assert( dyp >= 0 && dyp < 1.0 );
105  Real dxm = 1-dxp;
106  Real dym = 1-dyp;
107  Real binwx_over6 = binwx/6;
108  Real binwy_over6 = binwy/6;
109  Real dx3p = ( dxp*dxp*dxp - dxp) * binwx*binwx_over6;
110  Real dx3m = ( dxm*dxm*dxm - dxm) * binwx*binwx_over6;
111  Real dy3p = ( dyp*dyp*dyp - dyp) * binwy*binwy_over6;
112  Real dy3m = ( dym*dym*dym - dym) * binwy*binwy_over6;
113  Real invbinwx = 1/binwx;
114  Real invbinwy = 1/binwy;
115 
116  /* val =
117  dxm * ( dym * values_( ( i - 1) % dimx, ( j - 1) % dimy) + dyp * values_( ( i - 1) % dimx, j % dimy))
118  + dxp * ( dym * values_( i % dimx, ( j - 1) % dimy) + dyp * values_( i % dimx, j % dimy))
119  +dx3m * ( dym * dsecox_( ( i - 1) % dimx, ( j - 1) % dimy) + dyp * dsecox_( ( i - 1) % dimx, j % dimy))
120  +dx3p * ( dym * dsecox_( i % dimx, ( j - 1) % dimy) + dyp * dsecox_( i % dimx, j % dimy))
121  + dxm * ( dy3m * dsecoy_( ( i - 1) % dimx, ( j - 1) % dimy) + dy3p * dsecoy_( ( i - 1) % dimx, j % dimy))
122  + dxp * ( dy3m * dsecoy_( i % dimx, ( j - 1) % dimy) + dy3p * dsecoy_( i % dimx, j % dimy))
123  +dx3m * ( dy3m * dsecoxy_( ( i - 1) % dimx, ( j - 1) % dimy) + dy3p * dsecoxy_( ( i - 1) % dimx, j % dimy))
124  +dx3p * ( dy3m * dsecoxy_( i % dimx, ( j - 1) % dimy) + dy3p * dsecoxy_( i % dimx, j % dimy))*/
125  val =
126  dxm * ( dym * v00 + dyp * v01 )
127  + dxp * ( dym * v10 + dyp * v11 )
128  +dx3m * ( dym * d2dx200 + dyp * d2dx201 )
129  +dx3p * ( dym * d2dx210 + dyp * d2dx211 )
130  + dxm * ( dy3m * d2dy200 + dy3p * d2dy201 )
131  + dxp * ( dy3m * d2dy210 + dy3p * d2dy211 )
132  +dx3m * ( dy3m * d4dx2y200 + dy3p * d4dx2y201 )
133  +dx3p * ( dy3m * d4dx2y210 + dy3p * d4dx2y211 );
134 
135  /*dvaldx = -( dym * values_( ( i - 1) % dimx, ( j - 1) % dimy) + dyp * values_( ( i - 1) % dimx , j % dimy)) / delta_[ 0]
136  +( dym * values_( i % dimx , ( j - 1) % dimy) + dyp * values_( i % dimx , j % dimy)) / delta_[ 0]
137  - ( 3 * dxm * dxm - 1) * delta_[ 0] / 6 *( dym*dsecox_( ( i - 1) % dimx, ( j - 1) % dimy) + dyp * dsecox_( ( i - 1) % dimx, j%dimy))
138  + ( 3 * dxp * dxp - 1) * delta_[ 0] / 6 *( dym*dsecox_( i % dimx , ( j - 1) % dimy) + dyp * dsecox_( i % dimx , j%dimy))
139  -( dy3m * dsecoy_( ( i - 1) % dimx , ( j - 1) % dimy) + dy3p * dsecoy_( ( i-1) % dimx , j % dimy)) / delta_[ 0]
140  +( dy3m * dsecoy_( i % dimx , ( j - 1) % dimy) + dy3p * dsecoy_( i % dimx , j % dimy)) / delta_[ 0]
141  - ( 3 * dxm * dxm - 1) * delta_[ 0] / 6 *( dy3m*dsecoxy_( ( i - 1)%dimx, ( j - 1) % dimy) + dy3p * dsecoxy_( ( i - 1) % dimx, j % dimy))
142  + ( 3 * dxp * dxp - 1) * delta_[ 0] / 6 *( dy3m*dsecoxy_( i % dimx , ( j - 1) % dimy) + dy3p * dsecoxy_( i % dimx , j % dimy));*/
143 
144  dvaldx =
145  -( dym * v00 + dyp * v01 ) * invbinwx
146  +( dym * v10 + dyp * v11 ) * invbinwx
147  - ( 3 * dxm * dxm - 1) * binwx_over6 *( dym * d2dx200 + dyp * d2dx201 )
148  + ( 3 * dxp * dxp - 1) * binwx_over6 *( dym * d2dx210 + dyp * d2dx211 )
149  -( dy3m * d2dy200 + dy3p * d2dy201 ) * invbinwx
150  +( dy3m * d2dy210 + dy3p * d2dy211 ) * invbinwx
151  - ( 3 * dxm * dxm - 1) * binwx_over6 *( dy3m * d4dx2y200 + dy3p * d4dx2y201 )
152  + ( 3 * dxp * dxp - 1) * binwx_over6 *( dy3m * d4dx2y210 + dy3p * d4dx2y211 );
153 
154  /*dvaldy =
155  dxm *( -values_( ( i-1)%dimx , (j-1)%dimy)+values_( (i-1)%dimx , j%dimy))/delta_[ 1]
156  + dxp *( -values_( i%dimx , (j-1)%dimy)+values_(i%dimx , j%dimy))/delta_[ 1]
157  +dx3m *( -dsecox_( ( i-1)%dimx , (j-1)%dimy)+dsecox_( (i-1)%dimx , j%dimy))/delta_[ 1]
158  +dx3p *( -dsecox_( i%dimx , (j-1)%dimy)+dsecox_(i%dimx , j%dimy))/delta_[ 1]
159  + dxm *( -( 3 * dym * dym - 1) * dsecoy_( ( i-1)%dimx , ( j - 1)% dimy) +( 3 * dyp * dyp - 1) * dsecoy_( ( i-1)%dimx , j % dimy)) * delta_[ 1]/ 6
160  + dxp *( -( 3 * dym * dym - 1) * dsecoy_( i%dimx , ( j - 1)% dimy) +( 3 * dyp * dyp - 1) * dsecoy_( i%dimx , j % dimy)) * delta_[ 1]/ 6
161  + dx3m *( -( 3 * dym * dym - 1) * dsecoxy_( ( i-1)%dimx, ( j - 1)% dimy) +( 3 * dyp * dyp - 1) * dsecoxy_( ( i-1)%dimx, j % dimy)) * delta_[ 1]/ 6
162  +dx3p *( -( 3 * dym * dym - 1) * dsecoxy_( i%dimx , ( j - 1)% dimy) +( 3 * dyp * dyp - 1) * dsecoxy_( i%dimx , j % dimy)) * delta_[ 1]/ 6;*/
163 
164  dvaldy =
165  dxm *( -v00 + v01 ) * invbinwy
166  + dxp *( -v10 + v11 ) * invbinwy
167  +dx3m *( -d2dx200 + d2dx201) * invbinwy
168  +dx3p *( -d2dx210 + d2dx211) * invbinwy
169  + dxm *( -( 3 * dym * dym - 1) * d2dy200 + ( 3 * dyp * dyp - 1) * d2dy201 ) * binwy_over6
170  + dxp *( -( 3 * dym * dym - 1) * d2dy210 + ( 3 * dyp * dyp - 1) * d2dy211 ) * binwy_over6
171  +dx3m *( -( 3 * dym * dym - 1) * d4dx2y200 + ( 3 * dyp * dyp - 1) * d4dx2y201 ) * binwy_over6
172  +dx3p *( -( 3 * dym * dym - 1) * d4dx2y210 + ( 3 * dyp * dyp - 1) * d4dx2y211 ) * binwy_over6;
173 
174  //std::cout << "bicubic interpolation " << val << " " << dvaldx << " " << dvaldy << std::endl;
175 }
176 
177 void
178 tricubic_interpolation(
179  Real v000, Real dvdx000, Real dvdy000, Real dvdz000, Real dvdxy000, Real dvdxz000, Real dvdyz000, Real dvdxyz000,
180  Real v001, Real dvdx001, Real dvdy001, Real dvdz001, Real dvdxy001, Real dvdxz001, Real dvdyz001, Real dvdxyz001,
181  Real v010, Real dvdx010, Real dvdy010, Real dvdz010, Real dvdxy010, Real dvdxz010, Real dvdyz010, Real dvdxyz010,
182  Real v011, Real dvdx011, Real dvdy011, Real dvdz011, Real dvdxy011, Real dvdxz011, Real dvdyz011, Real dvdxyz011,
183  Real v100, Real dvdx100, Real dvdy100, Real dvdz100, Real dvdxy100, Real dvdxz100, Real dvdyz100, Real dvdxyz100,
184  Real v101, Real dvdx101, Real dvdy101, Real dvdz101, Real dvdxy101, Real dvdxz101, Real dvdyz101, Real dvdxyz101,
185  Real v110, Real dvdx110, Real dvdy110, Real dvdz110, Real dvdxy110, Real dvdxz110, Real dvdyz110, Real dvdxyz110,
186  Real v111, Real dvdx111, Real dvdy111, Real dvdz111, Real dvdxy111, Real dvdxz111, Real dvdyz111, Real dvdxyz111,
187  Real dxp, Real dyp, Real dzp,
188  Real binwx, Real binwy, Real binwz,
189  Real & val,
190  Real & dvaldx,
191  Real & dvaldy,
192  Real & dvaldz
193 )
194 {
195 
196  Real const invbinwx(1/binwx), invbinwy(1/binwy), invbinwz(1/binwz);
197  Real const binwx_over_6(binwx/6), binwy_over_6(binwy/6), binwz_over_6(binwz/6);
198  Real const dxm( 1-dxp), dym(1-dyp), dzm(1-dzp);
199 
200  Real const dx3p( ( dxp * dxp * dxp - dxp) * binwx * binwx_over_6 );
201  Real const dx3m( ( dxm * dxm * dxm - dxm) * binwx * binwx_over_6 );
202  Real const dy3p( ( dyp * dyp * dyp - dyp) * binwy * binwy_over_6 );
203  Real const dy3m( ( dym * dym * dym - dym) * binwy * binwy_over_6 );
204  Real const dz3p( ( dzp * dzp * dzp - dzp) * binwz * binwz_over_6 );
205  Real const dz3m( ( dzm * dzm * dzm - dzm) * binwz * binwz_over_6 );
206 
207  val=
208  dzm
209  *(dxm*(dym*v000+dyp*v010)
210  +dxp*(dym*v100+dyp*v110)
211  +dx3m*(dym*dvdx000+dyp*dvdx010)
212  +dx3p*(dym*dvdx100+dyp*dvdx110)
213  +dxm*(dy3m*dvdy000+dy3p*dvdy010)
214  +dxp*(dy3m*dvdy100+dy3p*dvdy110)
215  +dx3m*(dy3m*dvdxy000+dy3p*dvdxy010)
216  +dx3p*(dy3m*dvdxy100+dy3p*dvdxy110))
217 
218  +dzp
219  *(dxm*(dym*v001+dyp*v011)
220  +dxp*(dym*v101+dyp*v111)
221  +dx3m*(dym*dvdx001+dyp*dvdx011)
222  +dx3p*(dym*dvdx101+dyp*dvdx111)
223  +dxm*(dy3m*dvdy001+dy3p*dvdy011)
224  +dxp*(dy3m*dvdy101+dy3p*dvdy111)
225  +dx3m*(dy3m*dvdxy001+dy3p*dvdxy011)
226  +dx3p*(dy3m*dvdxy101+dy3p*dvdxy111))
227 
228  +dz3m
229  *(dxm*(dym*dvdz000+dyp*dvdz010)
230  +dxp*(dym*dvdz100+dyp*dvdz110)
231  +dx3m*(dym*dvdxz000+dyp*dvdxz010)
232  +dx3p*(dym*dvdxz100+dyp*dvdxz110)
233  +dxm*(dy3m*dvdyz000+dy3p*dvdyz010)
234  +dxp*(dy3m*dvdyz100+dy3p*dvdyz110)
235  +dx3m*(dy3m*dvdxyz000+dy3p*dvdxyz010)
236  +dx3p*(dy3m*dvdxyz100+dy3p*dvdxyz110))
237 
238  +dz3p
239  *(dxm*(dym*dvdz001+dyp*dvdz011)
240  +dxp*(dym*dvdz101+dyp*dvdz111)
241  +dx3m*(dym*dvdxz001+dyp*dvdxz011)
242  +dx3p*(dym*dvdxz101+dyp*dvdxz111)
243  +dxm*(dy3m*dvdyz001+dy3p*dvdyz011)
244  +dxp*(dy3m*dvdyz101+dy3p*dvdyz111)
245  +dx3m*(dy3m*dvdxyz001+dy3p*dvdxyz011)
246  +dx3p*(dy3m*dvdxyz101+dy3p*dvdxyz111));
247 
248  dvaldx=
249  dzm
250  *(
251  -(dym*v000+dyp*v010)*invbinwx
252  +(dym*v100+dyp*v110)*invbinwx
253  -(3*dxm*dxm-1)*binwx_over_6*(dym*dvdx000+dyp*dvdx010)
254  +(3*dxp*dxp-1)*binwx_over_6*(dym*dvdx100+dyp*dvdx110)
255  -(dy3m*dvdy000+dy3p*dvdy010)*invbinwx
256  +(dy3m*dvdy100+dy3p*dvdy110)*invbinwx
257  -(3*dxm*dxm-1)*binwx_over_6*(dy3m*dvdxy000+dy3p*dvdxy010)
258  +(3*dxp*dxp-1)*binwx_over_6*(dy3m*dvdxy100+dy3p*dvdxy110)
259  )
260 
261  +dzp
262  *(
263  -(dym*v001+dyp*v011)*invbinwx
264  +(dym*v101+dyp*v111)*invbinwx
265  -(3*dxm*dxm-1)*binwx_over_6*(dym*dvdx001+dyp*dvdx011)
266  +(3*dxp*dxp-1)*binwx_over_6*(dym*dvdx101+dyp*dvdx111)
267  -(dy3m*dvdy001+dy3p*dvdy011)*invbinwx
268  +(dy3m*dvdy101+dy3p*dvdy111)*invbinwx
269  -(3*dxm*dxm-1)*binwx_over_6*(dy3m*dvdxy001+dy3p*dvdxy011)
270  +(3*dxp*dxp-1)*binwx_over_6*(dy3m*dvdxy101+dy3p*dvdxy111)
271  )
272 
273  +dz3m
274  *(
275  -(dym*dvdz000+dyp*dvdz010)*invbinwx
276  +(dym*dvdz100+dyp*dvdz110)*invbinwx
277  -(3*dxm*dxm-1)*binwx_over_6*(dym*dvdxz000+dyp*dvdxz010)
278  +(3*dxp*dxp-1)*binwx_over_6*(dym*dvdxz100+dyp*dvdxz110)
279  -(dy3m*dvdyz000+dy3p*dvdyz010)*invbinwx
280  +(dy3m*dvdyz100+dy3p*dvdyz110)*invbinwx
281  -(3*dxm*dxm-1)*binwx_over_6*(dy3m*dvdxyz000+dy3p*dvdxyz010)
282  +(3*dxp*dxp-1)*binwx_over_6*(dy3m*dvdxyz100+dy3p*dvdxyz110)
283  )
284 
285  +dz3p
286  *(
287  -(dym*dvdz001+dyp*dvdz011)*invbinwx
288  +(dym*dvdz101+dyp*dvdz111)*invbinwx
289  -(3*dxm*dxm-1)*binwx_over_6*(dym*dvdxz001+dyp*dvdxz011)
290  +(3*dxp*dxp-1)*binwx_over_6*(dym*dvdxz101+dyp*dvdxz111)
291  -(dy3m*dvdyz001+dy3p*dvdyz011)*invbinwx
292  +(dy3m*dvdyz101+dy3p*dvdyz111)*invbinwx
293  -(3*dxm*dxm-1)*binwx_over_6*(dy3m*dvdxyz001+dy3p*dvdxyz011)
294  +(3*dxp*dxp-1)*binwx_over_6*(dy3m*dvdxyz101+dy3p*dvdxyz111));
295 
296  dvaldy=
297  dzm
298  *(
299  dxm*(-v000+v010)*invbinwy
300  +dxp*(-v100+v110)*invbinwy
301  +dx3m*(-dvdx000+dvdx010)*invbinwy
302  +dx3p*(-dvdx100+dvdx110)*invbinwy
303  +dxm*(-(3*dym*dym-1)*dvdy000+(3*dyp*dyp-1)*dvdy010)*binwy_over_6
304  +dxp*(-(3*dym*dym-1)*dvdy100+(3*dyp*dyp-1)*dvdy110)*binwy_over_6
305  +dx3m*(-(3*dym*dym-1)*dvdxy000+(3*dyp*dyp-1)*dvdxy010)*binwy_over_6
306  +dx3p*(-(3*dym*dym-1)*dvdxy100+(3*dyp*dyp-1)*dvdxy110)*binwy_over_6
307  )
308 
309  +dzp
310  *(
311  dxm*(-v001+v011)*invbinwy
312  +dxp*(-v101+v111)*invbinwy
313  +dx3m*(-dvdx001+dvdx011)*invbinwy
314  +dx3p*(-dvdx101+dvdx111)*invbinwy
315  +dxm*(-(3*dym*dym-1)*dvdy001+(3*dyp*dyp-1)*dvdy011)*binwy_over_6
316  +dxp*(-(3*dym*dym-1)*dvdy101+(3*dyp*dyp-1)*dvdy111)*binwy_over_6
317  +dx3m*(-(3*dym*dym-1)*dvdxy001+(3*dyp*dyp-1)*dvdxy011)*binwy_over_6
318  +dx3p*(-(3*dym*dym-1)*dvdxy101+(3*dyp*dyp-1)*dvdxy111)*binwy_over_6
319  )
320 
321  +dz3m
322  *(
323  dxm*(-dvdz000+dvdz010)*invbinwy
324  +dxp*(-dvdz100+dvdz110)*invbinwy
325  +dx3m*(-dvdxz000+dvdxz010)*invbinwy
326  +dx3p*(-dvdxz100+dvdxz110)*invbinwy
327  +dxm*(-(3*dym*dym-1)*dvdyz000+(3*dyp*dyp-1)*dvdyz010)*binwy_over_6
328  +dxp*(-(3*dym*dym-1)*dvdyz100+(3*dyp*dyp-1)*dvdyz110)*binwy_over_6
329  +dx3m*(-(3*dym*dym-1)*dvdxyz000+(3*dyp*dyp-1)*dvdxyz010)*binwy_over_6
330  +dx3p*(-(3*dym*dym-1)*dvdxyz100+(3*dyp*dyp-1)*dvdxyz110)*binwy_over_6
331  )
332 
333  +dz3p
334  *(
335  dxm*(-dvdz001+dvdz011)*invbinwy
336  +dxp*(-dvdz101+dvdz111)*invbinwy
337  +dx3m*(-dvdxz001+dvdxz011)*invbinwy
338  +dx3p*(-dvdxz101+dvdxz111)*invbinwy
339  +dxm*(-(3*dym*dym-1)*dvdyz001+(3*dyp*dyp-1)*dvdyz011)*binwy_over_6
340  +dxp*(-(3*dym*dym-1)*dvdyz101+(3*dyp*dyp-1)*dvdyz111)*binwy_over_6
341  +dx3m*(-(3*dym*dym-1)*dvdxyz001+(3*dyp*dyp-1)*dvdxyz011)*binwy_over_6
342  +dx3p*(-(3*dym*dym-1)*dvdxyz101+(3*dyp*dyp-1)*dvdxyz111)*binwy_over_6);
343 
344  dvaldz=
345  -(dxm*(dym*v000+dyp*v010)
346  +dxp*(dym*v100+dyp*v110)
347  +dx3m*(dym*dvdx000+dyp*dvdx010)
348  +dx3p*(dym*dvdx100+dyp*dvdx110)
349  +dxm*(dy3m*dvdy000+dy3p*dvdy010)
350  +dxp*(dy3m*dvdy100+dy3p*dvdy110)
351  +dx3m*(dy3m*dvdxy000+dy3p*dvdxy010)
352  +dx3p*(dy3m*dvdxy100+dy3p*dvdxy110))
353  *invbinwz
354 
355  +(dxm*(dym*v001+dyp*v011)
356  +dxp*(dym*v101+dyp*v111)
357  +dx3m*(dym*dvdx001+dyp*dvdx011)
358  +dx3p*(dym*dvdx101+dyp*dvdx111)
359  +dxm*(dy3m*dvdy001+dy3p*dvdy011)
360  +dxp*(dy3m*dvdy101+dy3p*dvdy111)
361  +dx3m*(dy3m*dvdxy001+dy3p*dvdxy011)
362  +dx3p*(dy3m*dvdxy101+dy3p*dvdxy111))
363  *invbinwz
364 
365  -(3*dzm*dzm-1)*binwz_over_6
366  *(dxm*(dym*dvdz000+dyp*dvdz010)
367  +dxp*(dym*dvdz100+dyp*dvdz110)
368  +dx3m*(dym*dvdxz000+dyp*dvdxz010)
369  +dx3p*(dym*dvdxz100+dyp*dvdxz110)
370  +dxm*(dy3m*dvdyz000+dy3p*dvdyz010)
371  +dxp*(dy3m*dvdyz100+dy3p*dvdyz110)
372  +dx3m*(dy3m*dvdxyz000+dy3p*dvdxyz010)
373  +dx3p*(dy3m*dvdxyz100+dy3p*dvdxyz110))
374 
375  +(3*dzp*dzp-1)*binwz_over_6
376  *(dxm*(dym*dvdz001+dyp*dvdz011)
377  +dxp*(dym*dvdz101+dyp*dvdz111)
378  +dx3m*(dym*dvdxz001+dyp*dvdxz011)
379  +dx3p*(dym*dvdxz101+dyp*dvdxz111)
380  +dxm*(dy3m*dvdyz001+dy3p*dvdyz011)
381  +dxp*(dy3m*dvdyz101+dy3p*dvdyz111)
382  +dx3m*(dy3m*dvdxyz001+dy3p*dvdxyz011)
383  +dx3p*(dy3m*dvdxyz101+dy3p*dvdxyz111));
384 
385 }
386 
387 
388 /// @details interpolates the angles and the sdevs as Reals (doubles)
389 void interpolate_rotamers(
390  DunbrackRotamer< FOUR > const & rot00,
391  DunbrackRotamer< FOUR > const & rot10,
392  DunbrackRotamer< FOUR > const & rot01,
393  DunbrackRotamer< FOUR > const & rot11,
394  Real phi_err, Real psi_err, Real binrange,
395  Size nchi_aa,
396  DunbrackRotamer< FOUR, Real > & interpolated_rotamer
397 )
398 {
399  using basic::interpolate_bilinear_by_value;
400  Real tmp1,tmp2;
401 
402 
403  for ( Size i = 1; i <= nchi_aa; ++i ) {
404 
405  // get the dunbrack chi angle means
406  Real interpolated_value;
407  interpolate_bilinear_by_value(
408  static_cast< Real > (rot00.chi_mean(i)),
409  static_cast< Real > (rot10.chi_mean(i)),
410  static_cast< Real > (rot01.chi_mean(i)),
411  static_cast< Real > (rot11.chi_mean(i)),
412  phi_err, psi_err, binrange, true /*treat_as_angles*/,
413  interpolated_value, tmp1, tmp2 );
414 
415  interpolated_rotamer.chi_mean( i, interpolated_value );
416 
417  // get the dunbrack chi angle sdevs
418  interpolate_bilinear_by_value(
419  static_cast< Real > (rot00.chi_sd(i)),
420  static_cast< Real > (rot10.chi_sd(i)),
421  static_cast< Real > (rot01.chi_sd(i)),
422  static_cast< Real > (rot11.chi_sd(i)),
423  phi_err, psi_err, binrange, false /*don't treat_as_angles */,
424  interpolated_value, tmp1, tmp2 );
425 
426  interpolated_rotamer.chi_sd( i, interpolated_value );
427 
428  interpolated_rotamer.rotwell( i, rot00.rotwell( i ) );
429 
430  // ctsa - check validity of result
431  if ( interpolated_rotamer.chi_sd(i) < 0.0 ) {
432  utility_exit_with_message( "interpolated_rotamer.chi_sd < 0 in fill_chi_set" );
433  }
434 
435  } // i=1, i<= nchi_aa_
436 
437  Real interpolated_prob;
438  interpolate_bilinear_by_value(
439  static_cast< Real > ( rot00.rotamer_probability()),
440  static_cast< Real > ( rot10.rotamer_probability()),
441  static_cast< Real > ( rot01.rotamer_probability()),
442  static_cast< Real > ( rot11.rotamer_probability()),
443  phi_err, psi_err, binrange, false /*dont' treat_as_angles*/ ,
444  interpolated_prob, tmp1, tmp2 );
445  interpolated_rotamer.rotamer_probability( interpolated_prob );
446 }
447 
448 
449 
450 /* OL: I thought copying the whole chi_set_vector is unnecessary and made a new version of this function */
451 void
452 expand_proton_chi_oldversion(
453  pack::task::ExtraRotSample ex_samp_level,
454  chemical::ResidueTypeCOP concrete_residue,
455  Size proton_chi,
456  utility::vector1< ChiSetOP > & chi_set_vector
457 )
458 {
459  using namespace pack::task;
460  // count the number of extra hydroxyl samples -- n
461  // copy the chi_set_vector n times into a temporary
462  // set the hydroxyl_chi value for these n samples in the temporary
463  // assign the temporary to the input chi_set_vector
464 
465  utility::vector1< Real > const & samples = concrete_residue->proton_chi_samples( proton_chi );
466  // i.e., -60, 60, 180
467 
468  // i.e., 10, 20 to model -40 -50 -60 -70 -80 etc.
469  utility::vector1< Real > const & extra_samples = concrete_residue->proton_chi_extra_samples( proton_chi );
470 
471  Size chi_id = concrete_residue->proton_chi_2_chi( proton_chi );
472 
473  bool const include_extra( ex_samp_level != NO_EXTRA_CHI_SAMPLES );
474 
475  Size nsamples = samples.size() * ( 1 + ( include_extra ? extra_samples.size() * 2 : 0 ) );
476  utility::vector1< ChiSetOP > newchi_vect( nsamples * chi_set_vector.size() );
477 
478  // copy old chi_set_vector nsample times
479  for ( Size ii = 1; ii <= nsamples; ++ii ) {
480  Size offset = (ii-1) * chi_set_vector.size();
481  for ( Size jj = 1; jj <= chi_set_vector.size(); ++jj ) {
482  newchi_vect[ jj + offset ] = new pack::dunbrack::ChiSet( *(chi_set_vector[ jj ]) );
483  }
484  }
485 
486  // add extra chi samples
487  Size count( 1 );
488  for ( Size ii = 1; ii <= samples.size(); ++ii ) {
489  Real ii_sample = samples[ ii ]; //chi-angle
490  for ( Size jj = 1; jj <= chi_set_vector.size(); ++jj ) {
491  newchi_vect[ count ]->chi[ chi_id ] = ii_sample;
492  ++count;
493  if ( include_extra ) {
494  for ( Size kk = 1; kk <= extra_samples.size(); ++kk ) {
495  newchi_vect[ count ]->chi[ chi_id ] = ii_sample + extra_samples[ kk ];
496  ++count;
497  newchi_vect[ count ]->chi[ chi_id ] = ii_sample - extra_samples[ kk ];
498  ++count;
499  }
500  }
501  }
502  }
503 
504  assert( count - 1 == nsamples * chi_set_vector.size() );
505  chi_set_vector = newchi_vect;
506 }
507 
508 /// olli -- I think this is slightly simpler to read than the original version
509 /// apl -- needs to find a new residence
510 void
511 expand_proton_chi(
512  pack::task::ExtraRotSample ex_samp_level,
513  chemical::ResidueTypeCOP concrete_residue,
514  Size proton_chi,
515  utility::vector1< ChiSetOP > & chi_set_vector
516 )
517 {
518  using namespace pack::task;
519  // count the number of extra hydroxyl samples -- n
520  // copy the chi_set_vector n times into a temporary
521  // set the hydroxyl_chi value for these n samples in the temporary
522  // assign the temporary to the input chi_set_vector
523 
524  utility::vector1< Real > const & samples = concrete_residue->proton_chi_samples( proton_chi );
525 
526  // i.e., -60, 60, 180
527  assert( samples.size() > 0 ); // or less harsh and just a return ?
528 
529  // i.e., 10, 20 to model -40 -50 -60 -70 -80 etc.
530  utility::vector1< Real > const & extra_samples = concrete_residue->proton_chi_extra_samples( proton_chi );
531 
532  Size chi_id = concrete_residue->proton_chi_2_chi( proton_chi );
533 
534  bool const include_extra( ex_samp_level != NO_EXTRA_CHI_SAMPLES );
535 
536  Size nsamples = samples.size() * ( 1 + ( include_extra ? extra_samples.size() * 2 : 0 ) );
537  chi_set_vector.reserve( nsamples * chi_set_vector.size() ); //preallocate the necessary memory
538 
539  // add extra chi samples
540  ChiSetOP new_chi_vec; ChiSetOP base_chi_vec;
541  Size nr_of_old_elem = chi_set_vector.size();
542  for ( Size jj = 1; jj <= nr_of_old_elem; ++jj ) {
543  for ( Size ii = 1; ii <= samples.size(); ++ii ) {
544  Real ii_sample = samples[ ii ]; //chi-angle
545  if (ii == 1) { //change first chi in place:
546  base_chi_vec = new_chi_vec = chi_set_vector[ jj ];
547  } else { // make copys for all others
548  new_chi_vec = new pack::dunbrack::ChiSet( *base_chi_vec );
549  chi_set_vector.push_back( new_chi_vec );
550  }
551  new_chi_vec->chi[ chi_id ] = ii_sample;
552 
553  if ( include_extra ) {
554  for ( Size kk = 1; kk <= extra_samples.size(); ++kk ) {
555  chi_set_vector.push_back( new_chi_vec = new pack::dunbrack::ChiSet( *base_chi_vec ) );
556  new_chi_vec->chi[ chi_id ] = ii_sample + extra_samples[ kk ];
557  chi_set_vector.push_back( new_chi_vec = new pack::dunbrack::ChiSet( *base_chi_vec ) );
558  new_chi_vec->chi[ chi_id ] = ii_sample - extra_samples[ kk ];
559  } // for extra_samples
560  } // include extra
561  } // for sample.size()
562  } // for jj (chi_set_vector)
563 
564  assert( chi_set_vector.size() == nsamples * nr_of_old_elem );
565 }
566 
567 
568 
569 DunbrackRotamerSampleData::DunbrackRotamerSampleData() :
570  nrchi_sample_( false ),
571  nchi_( 0 ),
572  probability_( 0.0 ),
573  nrchi_lower_boundary_( 0.0 ),
574  nrchi_upper_boundary_( 0.0 ),
575  nrchi_probability_( 0.0 )
576 {}
577 
578 DunbrackRotamerSampleData::DunbrackRotamerSampleData( bool is_nrchi_sample ) :
579  nrchi_sample_( is_nrchi_sample ),
580  nchi_( 0 ),
581  probability_( 0.0 ),
582  nrchi_lower_boundary_( 0.0 ),
583  nrchi_upper_boundary_( 0.0 ),
584  nrchi_probability_( 0.0 )
585 {}
586 
587 DunbrackRotamerSampleData::~DunbrackRotamerSampleData() {}
588 
589 void DunbrackRotamerSampleData::set_nrchi_sample( bool setting )
590 {
591  nrchi_sample_ = setting;
592 }
593 
594 void DunbrackRotamerSampleData::set_nchi( Size nchi ) {
595  assert( nchi_ <= DUNBRACK_MAX_SCTOR );
596  nchi_ = nchi;
597 }
598 
599 void DunbrackRotamerSampleData::set_rotwell( Size chi_index, Size rotwell )
600 {
601  assert( chi_index > 0 && chi_index <= nchi_ );
602  rot_well_[ chi_index ] = rotwell;
603 }
604 
605 void DunbrackRotamerSampleData::set_rotwell( utility::vector1< Size > const & rotwell )
606 {
607  assert( ( ! nrchi_sample_ && rotwell.size() == nchi_ ) ||
608  ( nrchi_sample_ && rotwell.size() == nchi_ - 1 ) );
609  std::copy( rotwell.begin(), rotwell.end(), rot_well_.begin() );
610 }
611 
612 void DunbrackRotamerSampleData::set_chi_mean( Size chi_index, Real mean )
613 {
614  assert( chi_index > 0 && chi_index <= nchi_ );
615  chi_mean_[ chi_index ] = mean;
616 }
617 
618 void DunbrackRotamerSampleData::set_chi_sd( Size chi_index, Real sd )
619 {
620  assert( chi_index > 0 && chi_index <= nchi_ );
621  chi_sd_[ chi_index ] = sd;
622 }
623 
624 void DunbrackRotamerSampleData::set_prob( Real probability )
625 {
626  probability_ = probability;
627 }
628 
629 void DunbrackRotamerSampleData::set_nrchi_lower_boundary( Real low )
630 {
631  assert( nrchi_sample_ );
632  nrchi_lower_boundary_ = low;
633 }
634 
635 void DunbrackRotamerSampleData::set_nrchi_upper_boundary( Real high )
636 {
637  assert( nrchi_sample_ );
638  nrchi_upper_boundary_ = high;
639 }
640 
641 void DunbrackRotamerSampleData::set_nrchi_probability( Real nrchi_prob )
642 {
643  assert( nrchi_sample_ );
644  nrchi_probability_ = nrchi_prob;
645 }
646 
647 void
648 DunbrackRotamerSampleData::assign_random_chi(
649  utility::vector1< Real > & chi_angles,
650  numeric::random::RandomGenerator & RG,
651  core::Real temperature /* scale distributions like a temperature, default 1.0 = is xray temperature */
652 ) const
653 {
654  assert( chi_angles.size() >= nchi() );
655 
656  for ( core::Size ii = 1; ii <= nchi(); ++ii ) {
657  //if ( chi_is_nonrotameric( ii ) ) {
658  // nonrotameric chi angles not currently supported
659  //runtime_assert( false );
660  //} else {
661  chi_angles[ ii ] = basic::periodic_range( chi_mean_[ii] + RG.gaussian() * chi_sd_[ii] * temperature, 360.0 );
662  //}
663  }
664 
665  // set any remaining chi uniformly (proton chi)
666  for ( core::Size ii = nchi()+1; ii <= chi_angles.size(); ++ii ) {
667  chi_angles[ ii ] = basic::periodic_range( RG.uniform()*360.0 - 180.0, 360.0 );
668  }
669 }
670 
671 Real
672 DunbrackRotamerSampleData::chi_probability(
673  utility::vector1< Real > const & chi_angles,
674  core::Real temperature /* scale distributions like a temperature, default 1.0 = is xray temperature */
675 ) const
676 {
677  assert( chi_angles.size() >= nchi() );
678  Real const norm_gauss( std::sqrt( numeric::constants::r::pi_2 ) );
679  Real prob(1);
680 
681  for ( Size ii = 1; ii <= nchi(); ++ii ) {
682  //if ( chi_is_nonrotameric( ii ) ) {
683  // nonrotameric chi angles not currently supported
684  //runtime_assert( false );
685  //} else {
686  // Gaussian function with area 1 for rotameric angles
687  Real const angle_diff( chi_mean_[ii] - numeric::nearest_angle_degrees( chi_angles[ii], chi_mean_[ii] ) );
688  Real const sd ( chi_sd_[ii] * temperature );
689  Real const variance( sd*sd );
690  prob *= std::exp( -(angle_diff*angle_diff)/(2*variance) ) / sd / norm_gauss;
691  //}
692  }
693 
694  for ( Size ii = nchi()+1; ii <= chi_angles.size(); ++ii ) {
695  // uniform function with area 1 for all other angles
696  prob *= 1.0 / 360.0;
697  }
698 
699  return prob;
700 }
701 
702 } // namespace dunbrack
703 } // namespace scoring
704 } // namespace core
Generated on Sat Jun 1 2013 11:33:15 for Rosetta 3.5 by   doxygen 1.8.4