ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/freemol/branches/sync4pymol12/src/mengine/src/ktorsion.c
(Generate patch)
# Line 1 | Line 1
1 < #define EXTERN extern
2 <
3 < #include "pcwin.h"
4 < #include "pcmod.h"
5 < #include "torsions.h"
6 < #include "rings.h"
7 < #include "field.h"
8 < #include "atom_k.h"
9 < #include "fix.h"
10 <
11 < int isbond(int,int);
12 < int is_delocalbond(int,int);
13 < void numeral(int,char *,int);
14 < void angle(int,int,int,float *);
15 < void four(char *,char *,char *,char *, char *);
16 < int is_ring42(int,int);
17 < int is_ring54(int, int, int, int);
18 < void message_alert(char *, char *);
19 < void  transomeg(float *, float *, float *, int *, int *, char *, char *, char *, char *,
20 <         char *, char *, char *, char *, char *, char *, char *);
21 <        
22 < EXTERN struct t_allene {
23 <    int nallene, ntor[10];
24 <     } allene;
25 <        
26 <        
27 < EXTERN struct t_torkn1 {
28 <        int  use_tor4, use_tor5;
29 <        int  ntor, ntor4, ntor5, ntordel, torindex[MAXTORDEL];
30 <        char  kv[MAXTORCONST][13], kv4[MAXTOR4CONST][13], kv5[MAXTOR5CONST][13];
31 <        char  kvdel[MAXTORDEL][13];
32 <        float tv1[MAXTORCONST], tv2[MAXTORCONST], tv3[MAXTORCONST];
33 <        float tv4[MAXTORCONST], tv5[MAXTORCONST], tv6[MAXTORCONST];
34 <        int   phase1[MAXTORCONST], phase2[MAXTORCONST], phase3[MAXTORCONST];
35 <        int   phase4[MAXTORCONST], phase5[MAXTORCONST], phase6[MAXTORCONST];
36 <        float tv41[MAXTOR4CONST], tv42[MAXTOR4CONST], tv43[MAXTOR4CONST];
37 <        int   phase41[MAXTOR4CONST], phase42[MAXTOR4CONST], phase43[MAXTOR4CONST];
38 <        float tv51[MAXTOR5CONST], tv52[MAXTOR5CONST], tv53[MAXTOR5CONST];
39 <        int   phase51[MAXTOR5CONST], phase52[MAXTOR5CONST], phase53[MAXTOR5CONST];
40 <        float tvdel1[MAXTORDEL], tvdel2[MAXTORDEL], tvdel3[MAXTORDEL];
41 <        int   phasedel1[MAXTORDEL], phasedel2[MAXTORDEL], phasedel3[MAXTORDEL];
42 <        } torkn1;
43 <
44 < EXTERN struct t_torknp {
45 <        int npitor;
46 <        char kp[MAXPITORCONST][13];
47 <        int ph1[MAXPITORCONST], ph2[MAXPITORCONST], ph3[MAXPITORCONST];
48 <        float   tv1[MAXPITORCONST], tv2[MAXPITORCONST], tv3[MAXPITORCONST];
49 <        } torknp;
50 <
51 <
52 < EXTERN struct t_ts_bondorder {
53 <        float fbnd[15];
54 <        }       ts_bondorder;
55 < EXTERN struct t_high_coord {
56 <        int ncoord, i13[400][3];
57 <        } high_coord;
58 <        
59 < EXTERN int Missing_constants;
60 < //EXTERN FILE *errfile;
61 <
62 < void ktorsion()
63 < {
64 <    int i, j, ierr, itor, ii, ki, k;
65 <    int ia, ib, ic, id;
66 <    int ita, itb, itc, itd;
67 <    int cl_a, cl_b, cl_c, cl_d;
68 <    int use_ring4, use_ring5;
69 <    long int mask;
70 <    char izero[4];
71 <    char pa[4],pb[4],pc[4],pd[4],pt[13], kv1[13];
72 <    char k1[13], k2[13], k3[13], k4[13], k5[13], k6[13], k7[13], k8[13], k9[13], k10[13],
73 <              k11[13], k12[13], k13[13], k14[13], k15[13];
74 <    float v1, v2, v3, rangle;
75 <
76 <    mask = (1L << 0);
77 <    itor = 0;
78 <    use_ring4 = FALSE;
79 <    if (rings.nring4 > 0 && torkn1.ntor4 > 0)
80 <       use_ring4 = TRUE;
81 <
82 <    use_ring5 = FALSE;
83 <    if (rings.nring5 > 0 && torkn1.ntor5 > 0)
84 <       use_ring5 = TRUE;
85 <
86 <    for (i=0; i < torsions.ntor; i++)
87 <    {
88 <        ia = torsions.i14[i][0];
89 <        ib = torsions.i14[i][1];
90 <        ic = torsions.i14[i][2];
91 <        id = torsions.i14[i][3];
92 <
93 <        ita = atom[ia].type;
94 <        itb = atom[ib].type;
95 <        itc = atom[ic].type;
96 <        itd = atom[id].type;
97 <
98 <        cl_a = atom[ia].tclass;
99 <        cl_b = atom[ib].tclass;
100 <        cl_c = atom[ic].tclass;
101 <        cl_d = atom[id].tclass;
102 <
103 <        if (field.type == MMX)
104 <        {
105 <            if (ita == 40)
106 <               ita = 2;
107 <            if (itb == 40)
108 <               itb = 2;
109 <            if (itc == 40)
110 <               itc = 2;
111 <            if (itd == 40)
112 <               itd = 2;
113 <
114 <            if (ita == 56 && itb == 56 && itc == 56 && itd == 56)
115 <            {
116 <                ita = 1; itb = 1; itc = 1; itd = 1;
117 <            }
118 <        }
119 <        numeral(ita,pa,3);
120 <        numeral(itb,pb,3);
121 <        numeral(itc,pc,3);
122 <        numeral(itd,pd,3);
123 <        
124 <        if (itb < itc )
125 <           four(pa,pb, pc, pd, pt);
126 <        else if (itb > itc)
127 <           four(pd,pc, pb, pa, pt);
128 <        else if (ita < itd)
129 <           four(pa,pb, pc, pd, pt);
130 <        else
131 <           four(pd,pc, pb, pa, pt);
132 <        strcpy(izero,"  0");
133 <
134 <        if (field.type == MMFF94)
135 <        {
136 <
137 <           numeral(atom_k.tclass1[ita],pa,3);
138 <           numeral(atom_k.tclass[itb],pb,3);
139 <           numeral(atom_k.tclass[itc],pc,3);
140 <           numeral(atom_k.tclass1[itd],pd,3);
141 <          
142 <        
143 <           if (atom_k.tclass[itb] < atom_k.tclass[itc] )
144 <           {
145 <              four(pa, pb, pc, izero,k2);
146 <              four(izero ,pb, pc, pd,k3);
147 <           } else if (atom_k.tclass[itb] > atom_k.tclass[itc])
148 <           {
149 <              four(izero,pc, pb, pa, k2);
150 <              four(pd,pc, pb, izero, k3);
151 <           } else if (atom_k.tclass1[ita] < atom_k.tclass1[itd])
152 <           {
153 <              four(pa,pb, pc, izero, k2);
154 <              four(izero,pb, pc, pd, k3);
155 <           } else
156 <           {
157 <              four(izero,pc, pb, pa, k2);
158 <              four(pd,pc, pb, izero, k3);
159 <           }
160 <        } else
161 <        {
162 <           four( izero, pc, pb, pa, k1 );
163 <           four( pd, pc, pb, izero, k2 );
164 <           four( izero, pb, pc, pd, k3 );
165 <        }
166 <        
167 <        numeral(ita,pa,3);
168 <        numeral(itb,pb,3);
169 <        numeral(itc,pc,3);
170 <        numeral(itd,pd,3);
171 <
172 <        four( pa, pb, pc, izero, k4 );
173 <        four( izero, pc, pb, izero, k5 );
174 <        four( izero, pb, pc, izero, k6 );
175 <        four( pd, pc, izero, izero, k7 );
176 <        four( izero, izero, pc,pd, k8 );
177 <
178 <        four( izero, izero, pb, pa, k9 );
179 <        four( pa, pb, izero, izero, k10 );
180 <        four( izero, izero, pc, izero, k11 );
181 <        four( izero, pc, izero, izero, k12 );
182 <        four( izero, izero, pb, izero, k13 );
183 <        four( izero, pb, izero, izero, k14 );
184 <
185 <        numeral(cl_a,pa,3);
186 <        numeral(cl_b,pb,3);
187 <        numeral(cl_c,pc,3);
188 <        numeral(cl_d,pd,3);
189 <        if (itb < itc )
190 <           four(pa,pb, pc, pd, k15);
191 <        else if (itb > itc)
192 <           four(pd,pc, pb, pa, k15);
193 <        else if (ita < itd)
194 <           four(pa,pb, pc, pd, k15);
195 <        else
196 <           four(pd,pc, pb, pa, k15);
197 <
198 <        ierr = FALSE;
199 < //   check for linear angles in high coordinate atoms
200 <        if (high_coord.ncoord > 0)
201 <        {
202 <            for (k = 0; k < high_coord.ncoord; k++)
203 <            {
204 <                if (high_coord.i13[k][1] == ib) // high coordinate atom in center
205 <                {
206 <                    if (high_coord.i13[k][0] == ia && high_coord.i13[k][2] == ic)
207 <                    {
208 <                        angle(ia,ib,ic,&rangle);
209 <                        if (rangle > 175 || rangle < -175)
210 <                        {
211 <                           torsions.v1[i] = 0.0;
212 <                           torsions.v2[i] = 0.0;
213 <                           torsions.v3[i] = 0.0;
214 <                           ierr = TRUE;
215 <                           goto L_10;
216 <                        }
217 <                    } else if (high_coord.i13[k][2] == ia && high_coord.i13[k][0] == ic)
218 <                    {
219 <                        angle(ia,ib,ic,&rangle);
220 <                        if (rangle > 175 || rangle < -175)
221 <                        {
222 <                           torsions.v1[i] = 0.0;
223 <                           torsions.v2[i] = 0.0;
224 <                           torsions.v3[i] = 0.0;
225 <                           ierr = TRUE;
226 <                           goto L_10;
227 <                        }
228 <                    }
229 <                } else if ( high_coord.i13[k][1] == ic)
230 <                {
231 <                    if (high_coord.i13[k][0] == ib && high_coord.i13[k][2] == id)
232 <                    {
233 <                        angle(ib,ic,id,&rangle);
234 <                        if (rangle > 175 || rangle < -175)
235 <                        {
236 <                           torsions.v1[i] = 0.0;
237 <                           torsions.v2[i] = 0.0;
238 <                           torsions.v3[i] = 0.0;
239 <                           ierr = TRUE;
240 <                           goto L_10;
241 <                        }
242 <                    } else if (high_coord.i13[k][2] == ib&& high_coord.i13[k][0] == id)
243 <                    {
244 <                        angle(ib,ic,id,&rangle);
245 <                        if (rangle > 175 || rangle < -175)
246 <                        {
247 <                           torsions.v1[i] = 0.0;
248 <                           torsions.v2[i] = 0.0;
249 <                           torsions.v3[i] = 0.0;
250 <                           ierr = TRUE;
251 <                           goto L_10;
252 <                        }
253 <                    }
254 <                }
255 <            }
256 <        }
257 <                    
258 < //  check for four membered rings
259 <        if ( isbond(ia,id) )
260 <        {
261 <          for(j=0; j < torkn1.ntor4; j++)
262 <          {
263 <             strcpy(kv1,torkn1.kv4[j]);
264 <             if (strcmp(pt,kv1) == 0 || strcmp(k1,kv1) == 0 || strcmp(k2,kv1) == 0 || strcmp(k3,kv1) == 0 ||      
265 <                 strcmp(k4,kv1) == 0 || strcmp(k5,kv1) == 0 || strcmp(k6,kv1) == 0 || strcmp(k7,kv1) == 0 ||      
266 <                 strcmp(k8,kv1) == 0 || strcmp(k9,kv1) == 0 || strcmp(k10,kv1) == 0 || strcmp(k11,kv1) == 0 ||      
267 <                 strcmp(k12,kv1) == 0 || strcmp(k13,kv1) == 0 || strcmp(k14,kv1) == 0 )
268 <             {
269 <               torsions.v1[i] =  torkn1.tv41[j];
270 <               torsions.ph1[i] = torkn1.phase41[j];    
271 <               torsions.v2[i] =  torkn1.tv42[j];
272 <               torsions.ph2[i] = torkn1.phase42[j];    
273 <               torsions.v3[i] =  torkn1.tv43[j];
274 <               torsions.ph3[i] = torkn1.phase43[j];
275 <               ierr = TRUE;
276 <               goto L_10;
277 <             }  
278 <          }
279 <        }
280 < //   delocalized torsions
281 <        if ( is_delocalbond(ib,ic) )
282 <        {
283 <          for(j=0; j < torkn1.ntordel; j++)
284 <          {
285 <             strcpy(kv1,torkn1.kvdel[j]);
286 <             if (strcmp(pt,kv1) == 0 || strcmp(k1,kv1) == 0 || strcmp(k2,kv1) == 0 || strcmp(k3,kv1) == 0 ||      
287 <                 strcmp(k4,kv1) == 0 || strcmp(k5,kv1) == 0 || strcmp(k6,kv1) == 0 || strcmp(k7,kv1) == 0 ||      
288 <                 strcmp(k8,kv1) == 0 || strcmp(k9,kv1) == 0 || strcmp(k10,kv1) == 0 || strcmp(k11,kv1) == 0 ||      
289 <                 strcmp(k12,kv1) == 0 || strcmp(k13,kv1) == 0 || strcmp(k14,kv1) == 0 )
290 <             {
291 <               torsions.v1[i] =  torkn1.tvdel1[j];
292 <               torsions.ph1[i] = torkn1.phasedel1[j];    
293 <               torsions.v2[i] =  torkn1.tvdel2[j];
294 <               torsions.ph2[i] = torkn1.phasedel2[j];    
295 <               torsions.v3[i] =  torkn1.tvdel3[j];
296 <               torsions.ph3[i] = torkn1.phasedel3[j];
297 <               ierr = TRUE;
298 <               goto L_10;
299 <             }  
300 <          }
301 <        }
302 < //   check for five membered rings
303 <         if (is_ring54(ia,ib,ic,id) )
304 <         {
305 <          for(j=0; j < torkn1.ntor5; j++)
306 <          {
307 <             strcpy(kv1,torkn1.kv5[j]);
308 <             if (strcmp(pt,kv1) == 0 || strcmp(k1,kv1) == 0 || strcmp(k2,kv1) == 0 || strcmp(k3,kv1) == 0 ||      
309 <                 strcmp(k4,kv1) == 0 || strcmp(k5,kv1) == 0 || strcmp(k6,kv1) == 0 || strcmp(k7,kv1) == 0 ||      
310 <                 strcmp(k8,kv1) == 0 || strcmp(k9,kv1) == 0 || strcmp(k10,kv1) == 0 || strcmp(k11,kv1) == 0 ||      
311 <                 strcmp(k12,kv1) == 0 || strcmp(k13,kv1) == 0 || strcmp(k14,kv1) == 0 )
312 <             {
313 <               torsions.v1[i] =  torkn1.tv51[j];
314 <               torsions.ph1[i] = torkn1.phase51[j];    
315 <               torsions.v2[i] =  torkn1.tv52[j];
316 <               torsions.ph2[i] = torkn1.phase52[j];    
317 <               torsions.v3[i] =  torkn1.tv53[j];
318 <               torsions.ph3[i] = torkn1.phase53[j];
319 <               ierr = TRUE;
320 <               goto L_10;
321 <             }  
322 <          }
323 <         }
324 < //   check regular parameters
325 <         if (field.type == MMFF94)
326 <         {
327 <             for(j=0; j < torkn1.ntor; j++)   // specific constants
328 <             {
329 <                 strcpy(kv1,torkn1.kv[j]);
330 <                 if (strcmp(pt,kv1) == 0)
331 <                 {
332 <                     torsions.v1[i] = torkn1.tv1[j];
333 <                     torsions.ph1[i] = torkn1.phase1[j];    
334 <                     torsions.v2[i] = torkn1.tv2[j];
335 <                     torsions.ph2[i] = torkn1.phase2[j];    
336 <                     torsions.v3[i] = torkn1.tv3[j];
337 <                     torsions.ph3[i] = torkn1.phase3[j];    
338 <                     torsions.v4[i] = torkn1.tv4[j];
339 <                     torsions.ph4[i] = torkn1.phase4[j];    
340 <                     torsions.v5[i] = torkn1.tv5[j];
341 <                     torsions.ph5[i] = torkn1.phase5[j];    
342 <                     torsions.v6[i] = torkn1.tv6[j];
343 <                     torsions.ph6[i] = torkn1.phase6[j];
344 <                     goto L_10;
345 <                 }
346 <             }
347 <             for(j=0; j < torkn1.ntor; j++)  //  class 2
348 <             {
349 <                 strcpy(kv1,torkn1.kv[j]);
350 <                 if (strcmp(k2,kv1) == 0 || strcmp(k3,kv1) == 0 )
351 <                 {
352 <                     torsions.v1[i] = torkn1.tv1[j];
353 <                     torsions.ph1[i] = torkn1.phase1[j];    
354 <                     torsions.v2[i] = torkn1.tv2[j];
355 <                     torsions.ph2[i] = torkn1.phase2[j];    
356 <                     torsions.v3[i] = torkn1.tv3[j];
357 <                     torsions.ph3[i] = torkn1.phase3[j];    
358 <                     torsions.v4[i] = torkn1.tv4[j];
359 <                     torsions.ph4[i] = torkn1.phase4[j];    
360 <                     torsions.v5[i] = torkn1.tv5[j];
361 <                     torsions.ph5[i] = torkn1.phase5[j];    
362 <                     torsions.v6[i] = torkn1.tv6[j];
363 <                     torsions.ph6[i] = torkn1.phase6[j];
364 <                     goto L_10;
365 <                 }
366 <             }
367 <             for(j=0; j < torkn1.ntor; j++)  // wild cards
368 <             {
369 <                 strcpy(kv1,torkn1.kv[j]);
370 <                 if (strcmp(k5,kv1) == 0 || strcmp(k6,kv1) == 0 || strcmp(k7,kv1) == 0 || strcmp(k8,kv1) == 0 )
371 <                 {
372 <                     torsions.v1[i] = torkn1.tv1[j];
373 <                     torsions.ph1[i] = torkn1.phase1[j];    
374 <                     torsions.v2[i] = torkn1.tv2[j];
375 <                     torsions.ph2[i] = torkn1.phase2[j];    
376 <                     torsions.v3[i] = torkn1.tv3[j];
377 <                     torsions.ph3[i] = torkn1.phase3[j];    
378 <                     torsions.v4[i] = torkn1.tv4[j];
379 <                     torsions.ph4[i] = torkn1.phase4[j];    
380 <                     torsions.v5[i] = torkn1.tv5[j];
381 <                     torsions.ph5[i] = torkn1.phase5[j];    
382 <                     torsions.v6[i] = torkn1.tv6[j];
383 <                     torsions.ph6[i] = torkn1.phase6[j];
384 <                     goto L_10;
385 <                 }
386 <             }
387 <         }              
388 < // check regular specific parameters
389 <         for(j=0; j < torkn1.ntor; j++)
390 <         {
391 <             strcpy(kv1,torkn1.kv[j]);
392 <             if (strcmp(pt,kv1) == 0)
393 <             {
394 <               torsions.v1[i] = torkn1.tv1[j];
395 <               torsions.ph1[i] = torkn1.phase1[j];    
396 <               torsions.v2[i] = torkn1.tv2[j];
397 <               torsions.ph2[i] = torkn1.phase2[j];    
398 <               torsions.v3[i] = torkn1.tv3[j];
399 <               torsions.ph3[i] = torkn1.phase3[j];    
400 <               torsions.v4[i] = torkn1.tv4[j];
401 <               torsions.ph4[i] = torkn1.phase4[j];    
402 <               torsions.v5[i] = torkn1.tv5[j];
403 <               torsions.ph5[i] = torkn1.phase5[j];    
404 <               torsions.v6[i] = torkn1.tv6[j];
405 <               torsions.ph6[i] = torkn1.phase6[j];
406 <               goto L_10;
407 <               break;
408 <             }  
409 <          }
410 < // check regular generalized parameters
411 <         for(j=0; j < torkn1.ntor; j++)
412 <         {
413 <             strcpy(kv1,torkn1.kv[j]);
414 <             if (strcmp(pt,kv1) == 0 || strcmp(k1,kv1) == 0 || strcmp(k2,kv1) == 0 || strcmp(k3,kv1) == 0 ||      
415 <                 strcmp(k4,kv1) == 0 || strcmp(k5,kv1) == 0 || strcmp(k6,kv1) == 0 || strcmp(k7,kv1) == 0 ||      
416 <                 strcmp(k8,kv1) == 0 || strcmp(k9,kv1) == 0 || strcmp(k10,kv1) == 0 || strcmp(k11,kv1) == 0 ||      
417 <                 strcmp(k12,kv1) == 0 || strcmp(k13,kv1) == 0 || strcmp(k14,kv1) == 0 || strcmp(k15,kv1) == 0)
418 <             {
419 <               torsions.v1[i] = torkn1.tv1[j];
420 <               torsions.ph1[i] = torkn1.phase1[j];    
421 <               torsions.v2[i] = torkn1.tv2[j];
422 <               torsions.ph2[i] = torkn1.phase2[j];    
423 <               torsions.v3[i] = torkn1.tv3[j];
424 <               torsions.ph3[i] = torkn1.phase3[j];    
425 <               torsions.v4[i] = torkn1.tv4[j];
426 <               torsions.ph4[i] = torkn1.phase4[j];    
427 <               torsions.v5[i] = torkn1.tv5[j];
428 <               torsions.ph5[i] = torkn1.phase5[j];    
429 <               torsions.v6[i] = torkn1.tv6[j];
430 <               torsions.ph6[i] = torkn1.phase6[j];
431 <               goto L_10;
432 <               break;
433 <             }  
434 <          }
435 < //  missing parameters
436 <          if (ierr == FALSE)
437 <          {
438 < //              Missing_constants = TRUE;
439 <          }
440 < L_10:
441 <    continue;
442 <    }
443 <
444 <    if (allene.nallene > 0)
445 <    {
446 <        for (i = 0; i < allene.nallene; i++)
447 <        {
448 <            torsions.v1[allene.ntor[i]] = 0;
449 <            torsions.v2[allene.ntor[i]] = -11.5;
450 <            torsions.v3[allene.ntor[i]] = 0;
451 <        }
452 <    }
453 < }
454 < /*  --------------------------------------------   */
455 < void four(char *pa, char *pb, char *pc, char *pd, char *pt)
456 < {
457 <        strcpy(pt,pa);
458 <        strcat(pt,pb);
459 <        strcat(pt,pc);
460 <        strcat(pt,pd);
461 < }
1 > #define EXTERN extern
2 >
3 > #include "pcwin.h"
4 > #include "pcmod.h"
5 > #include "torsions.h"
6 > #include "rings.h"
7 > #include "field.h"
8 > #include "atom_k.h"
9 >
10 > int isbond(int,int);
11 > int is_delocalbond(int,int);
12 > void numeral(int,char *,int);
13 > void angle(int,int,int,float *);
14 > void four(char *,char *,char *,char *, char *);
15 > int is_ring42(int,int);
16 > int is_ring54(int, int, int, int);
17 > void message_alert(char *, char *);
18 >        
19 > EXTERN struct t_allene {
20 >    int nallene, ntor[10];
21 >     } allene;
22 >        
23 >        
24 > EXTERN struct t_torkn1 {
25 >        int  use_tor4, use_tor5;
26 >        int  ntor, ntor4, ntor5, ntordel, torindex[MAXTORDEL];
27 >        char  kv[MAXTORCONST][13], kv4[MAXTOR4CONST][13], kv5[MAXTOR5CONST][13];
28 >        char  kvdel[MAXTORDEL][13];
29 >        float tv1[MAXTORCONST], tv2[MAXTORCONST], tv3[MAXTORCONST];
30 >        float tv4[MAXTORCONST], tv5[MAXTORCONST], tv6[MAXTORCONST];
31 >        int   phase1[MAXTORCONST], phase2[MAXTORCONST], phase3[MAXTORCONST];
32 >        int   phase4[MAXTORCONST], phase5[MAXTORCONST], phase6[MAXTORCONST];
33 >        float tv41[MAXTOR4CONST], tv42[MAXTOR4CONST], tv43[MAXTOR4CONST];
34 >        int   phase41[MAXTOR4CONST], phase42[MAXTOR4CONST], phase43[MAXTOR4CONST];
35 >        float tv51[MAXTOR5CONST], tv52[MAXTOR5CONST], tv53[MAXTOR5CONST];
36 >        int   phase51[MAXTOR5CONST], phase52[MAXTOR5CONST], phase53[MAXTOR5CONST];
37 >        float tvdel1[MAXTORDEL], tvdel2[MAXTORDEL], tvdel3[MAXTORDEL];
38 >        int   phasedel1[MAXTORDEL], phasedel2[MAXTORDEL], phasedel3[MAXTORDEL];
39 >        } torkn1;
40 >
41 > EXTERN struct t_torknp {
42 >        int npitor;
43 >        char kp[MAXPITORCONST][13];
44 >        int ph1[MAXPITORCONST], ph2[MAXPITORCONST], ph3[MAXPITORCONST];
45 >        float   tv1[MAXPITORCONST], tv2[MAXPITORCONST], tv3[MAXPITORCONST];
46 >        } torknp;
47 >
48 > EXTERN struct t_high_coord {
49 >        int ncoord, i13[400][3];
50 >        } high_coord;
51 >        
52 > EXTERN int Missing_constants;
53 > EXTERN FILE *errfile;
54 >
55 > void ktorsion()
56 > {
57 >    int i, j, ierr, itor, ii, ki, k;
58 >    int ia, ib, ic, id;
59 >    int ita, itb, itc, itd;
60 >    int cl_a, cl_b, cl_c, cl_d;
61 >    int use_ring4, use_ring5;
62 >    long int mask;
63 >    char izero[4];
64 >    char pa[4],pb[4],pc[4],pd[4],pt[13], kv1[13];
65 >    char k1[13], k2[13], k3[13], k4[13], k5[13], k6[13], k7[13], k8[13], k9[13], k10[13],
66 >              k11[13], k12[13], k13[13], k14[13], k15[13];
67 >    float v1, v2, v3, rangle;
68 >
69 >    mask = (1L << 0);
70 >    itor = 0;
71 >    use_ring4 = FALSE;
72 >    if (rings.nring4 > 0 && torkn1.ntor4 > 0)
73 >       use_ring4 = TRUE;
74 >
75 >    use_ring5 = FALSE;
76 >    if (rings.nring5 > 0 && torkn1.ntor5 > 0)
77 >       use_ring5 = TRUE;
78 >
79 >    for (i=0; i < torsions.ntor; i++)
80 >    {
81 >        ia = torsions.i14[i][0];
82 >        ib = torsions.i14[i][1];
83 >        ic = torsions.i14[i][2];
84 >        id = torsions.i14[i][3];
85 >
86 >        ita = atom[ia].type;
87 >        itb = atom[ib].type;
88 >        itc = atom[ic].type;
89 >        itd = atom[id].type;
90 >
91 >        cl_a = atom[ia].tclass;
92 >        cl_b = atom[ib].tclass;
93 >        cl_c = atom[ic].tclass;
94 >        cl_d = atom[id].tclass;
95 >
96 >        if (field.type == MMX)
97 >        {
98 >            if (ita == 40)
99 >               ita = 2;
100 >            if (itb == 40)
101 >               itb = 2;
102 >            if (itc == 40)
103 >               itc = 2;
104 >            if (itd == 40)
105 >               itd = 2;
106 >
107 >            if (ita == 56 && itb == 56 && itc == 56 && itd == 56)
108 >            {
109 >                ita = 1; itb = 1; itc = 1; itd = 1;
110 >            }
111 >        }
112 >        numeral(ita,pa,3);
113 >        numeral(itb,pb,3);
114 >        numeral(itc,pc,3);
115 >        numeral(itd,pd,3);
116 >        
117 >        if (itb < itc )
118 >           four(pa,pb, pc, pd, pt);
119 >        else if (itb > itc)
120 >           four(pd,pc, pb, pa, pt);
121 >        else if (ita < itd)
122 >           four(pa,pb, pc, pd, pt);
123 >        else
124 >           four(pd,pc, pb, pa, pt);
125 >        strcpy(izero,"  0");
126 >
127 >        if (field.type == MMFF94)
128 >        {
129 >
130 >           numeral(atom_k.tclass1[ita],pa,3);
131 >           numeral(atom_k.tclass[itb],pb,3);
132 >           numeral(atom_k.tclass[itc],pc,3);
133 >           numeral(atom_k.tclass1[itd],pd,3);
134 >          
135 >        
136 >           if (atom_k.tclass[itb] < atom_k.tclass[itc] )
137 >           {
138 >              four(pa, pb, pc, izero,k2);
139 >              four(izero ,pb, pc, pd,k3);
140 >           } else if (atom_k.tclass[itb] > atom_k.tclass[itc])
141 >           {
142 >              four(izero,pc, pb, pa, k2);
143 >              four(pd,pc, pb, izero, k3);
144 >           } else if (atom_k.tclass1[ita] < atom_k.tclass1[itd])
145 >           {
146 >              four(pa,pb, pc, izero, k2);
147 >              four(izero,pb, pc, pd, k3);
148 >           } else
149 >           {
150 >              four(izero,pc, pb, pa, k2);
151 >              four(pd,pc, pb, izero, k3);
152 >           }
153 >        } else
154 >        {
155 >           four( izero, pc, pb, pa, k1 );
156 >           four( pd, pc, pb, izero, k2 );
157 >           four( izero, pb, pc, pd, k3 );
158 >        }
159 >        
160 >        numeral(ita,pa,3);
161 >        numeral(itb,pb,3);
162 >        numeral(itc,pc,3);
163 >        numeral(itd,pd,3);
164 >
165 >        four( pa, pb, pc, izero, k4 );
166 >        four( izero, pc, pb, izero, k5 );
167 >        four( izero, pb, pc, izero, k6 );
168 >        four( pd, pc, izero, izero, k7 );
169 >        four( izero, izero, pc,pd, k8 );
170 >
171 >        four( izero, izero, pb, pa, k9 );
172 >        four( pa, pb, izero, izero, k10 );
173 >        four( izero, izero, pc, izero, k11 );
174 >        four( izero, pc, izero, izero, k12 );
175 >        four( izero, izero, pb, izero, k13 );
176 >        four( izero, pb, izero, izero, k14 );
177 >
178 >        numeral(cl_a,pa,3);
179 >        numeral(cl_b,pb,3);
180 >        numeral(cl_c,pc,3);
181 >        numeral(cl_d,pd,3);
182 >        if (itb < itc )
183 >           four(pa,pb, pc, pd, k15);
184 >        else if (itb > itc)
185 >           four(pd,pc, pb, pa, k15);
186 >        else if (ita < itd)
187 >           four(pa,pb, pc, pd, k15);
188 >        else
189 >           four(pd,pc, pb, pa, k15);
190 >
191 >        ierr = FALSE;
192 > //   check for linear angles in high coordinate atoms
193 >        if (high_coord.ncoord > 0)
194 >        {
195 >            for (k = 0; k < high_coord.ncoord; k++)
196 >            {
197 >                if (high_coord.i13[k][1] == ib) // high coordinate atom in center
198 >                {
199 >                    if (high_coord.i13[k][0] == ia && high_coord.i13[k][2] == ic)
200 >                    {
201 >                        angle(ia,ib,ic,&rangle);
202 >                        if (rangle > 175 || rangle < -175)
203 >                        {
204 >                           torsions.v1[i] = 0.0;
205 >                           torsions.v2[i] = 0.0;
206 >                           torsions.v3[i] = 0.0;
207 >                           ierr = TRUE;
208 >                           goto L_10;
209 >                        }
210 >                    } else if (high_coord.i13[k][2] == ia && high_coord.i13[k][0] == ic)
211 >                    {
212 >                        angle(ia,ib,ic,&rangle);
213 >                        if (rangle > 175 || rangle < -175)
214 >                        {
215 >                           torsions.v1[i] = 0.0;
216 >                           torsions.v2[i] = 0.0;
217 >                           torsions.v3[i] = 0.0;
218 >                           ierr = TRUE;
219 >                           goto L_10;
220 >                        }
221 >                    }
222 >                } else if ( high_coord.i13[k][1] == ic)
223 >                {
224 >                    if (high_coord.i13[k][0] == ib && high_coord.i13[k][2] == id)
225 >                    {
226 >                        angle(ib,ic,id,&rangle);
227 >                        if (rangle > 175 || rangle < -175)
228 >                        {
229 >                           torsions.v1[i] = 0.0;
230 >                           torsions.v2[i] = 0.0;
231 >                           torsions.v3[i] = 0.0;
232 >                           ierr = TRUE;
233 >                           goto L_10;
234 >                        }
235 >                    } else if (high_coord.i13[k][2] == ib&& high_coord.i13[k][0] == id)
236 >                    {
237 >                        angle(ib,ic,id,&rangle);
238 >                        if (rangle > 175 || rangle < -175)
239 >                        {
240 >                           torsions.v1[i] = 0.0;
241 >                           torsions.v2[i] = 0.0;
242 >                           torsions.v3[i] = 0.0;
243 >                           ierr = TRUE;
244 >                           goto L_10;
245 >                        }
246 >                    }
247 >                }
248 >            }
249 >        }
250 >                    
251 > //  check for four membered rings
252 >        if ( isbond(ia,id) )
253 >        {
254 >          for(j=0; j < torkn1.ntor4; j++)
255 >          {
256 >             strcpy(kv1,torkn1.kv4[j]);
257 >             if (strcmp(pt,kv1) == 0 || strcmp(k1,kv1) == 0 || strcmp(k2,kv1) == 0 || strcmp(k3,kv1) == 0 ||      
258 >                 strcmp(k4,kv1) == 0 || strcmp(k5,kv1) == 0 || strcmp(k6,kv1) == 0 || strcmp(k7,kv1) == 0 ||      
259 >                 strcmp(k8,kv1) == 0 || strcmp(k9,kv1) == 0 || strcmp(k10,kv1) == 0 || strcmp(k11,kv1) == 0 ||      
260 >                 strcmp(k12,kv1) == 0 || strcmp(k13,kv1) == 0 || strcmp(k14,kv1) == 0 )
261 >             {
262 >               torsions.v1[i] =  torkn1.tv41[j];
263 >               torsions.ph1[i] = torkn1.phase41[j];    
264 >               torsions.v2[i] =  torkn1.tv42[j];
265 >               torsions.ph2[i] = torkn1.phase42[j];    
266 >               torsions.v3[i] =  torkn1.tv43[j];
267 >               torsions.ph3[i] = torkn1.phase43[j];
268 >               ierr = TRUE;
269 >               goto L_10;
270 >             }  
271 >          }
272 >        }
273 > //   delocalized torsions
274 >        if ( is_delocalbond(ib,ic) )
275 >        {
276 >          for(j=0; j < torkn1.ntordel; j++)
277 >          {
278 >             strcpy(kv1,torkn1.kvdel[j]);
279 >             if (strcmp(pt,kv1) == 0 || strcmp(k1,kv1) == 0 || strcmp(k2,kv1) == 0 || strcmp(k3,kv1) == 0 ||      
280 >                 strcmp(k4,kv1) == 0 || strcmp(k5,kv1) == 0 || strcmp(k6,kv1) == 0 || strcmp(k7,kv1) == 0 ||      
281 >                 strcmp(k8,kv1) == 0 || strcmp(k9,kv1) == 0 || strcmp(k10,kv1) == 0 || strcmp(k11,kv1) == 0 ||      
282 >                 strcmp(k12,kv1) == 0 || strcmp(k13,kv1) == 0 || strcmp(k14,kv1) == 0 )
283 >             {
284 >               torsions.v1[i] =  torkn1.tvdel1[j];
285 >               torsions.ph1[i] = torkn1.phasedel1[j];    
286 >               torsions.v2[i] =  torkn1.tvdel2[j];
287 >               torsions.ph2[i] = torkn1.phasedel2[j];    
288 >               torsions.v3[i] =  torkn1.tvdel3[j];
289 >               torsions.ph3[i] = torkn1.phasedel3[j];
290 >               ierr = TRUE;
291 >               goto L_10;
292 >             }  
293 >          }
294 >        }
295 > //   check for five membered rings
296 >         if (is_ring54(ia,ib,ic,id) )
297 >         {
298 >          for(j=0; j < torkn1.ntor5; j++)
299 >          {
300 >             strcpy(kv1,torkn1.kv5[j]);
301 >             if (strcmp(pt,kv1) == 0 || strcmp(k1,kv1) == 0 || strcmp(k2,kv1) == 0 || strcmp(k3,kv1) == 0 ||      
302 >                 strcmp(k4,kv1) == 0 || strcmp(k5,kv1) == 0 || strcmp(k6,kv1) == 0 || strcmp(k7,kv1) == 0 ||      
303 >                 strcmp(k8,kv1) == 0 || strcmp(k9,kv1) == 0 || strcmp(k10,kv1) == 0 || strcmp(k11,kv1) == 0 ||      
304 >                 strcmp(k12,kv1) == 0 || strcmp(k13,kv1) == 0 || strcmp(k14,kv1) == 0 )
305 >             {
306 >               torsions.v1[i] =  torkn1.tv51[j];
307 >               torsions.ph1[i] = torkn1.phase51[j];    
308 >               torsions.v2[i] =  torkn1.tv52[j];
309 >               torsions.ph2[i] = torkn1.phase52[j];    
310 >               torsions.v3[i] =  torkn1.tv53[j];
311 >               torsions.ph3[i] = torkn1.phase53[j];
312 >               ierr = TRUE;
313 >               goto L_10;
314 >             }  
315 >          }
316 >         }
317 > //   check regular parameters
318 >         if (field.type == MMFF94)
319 >         {
320 >             for(j=0; j < torkn1.ntor; j++)   // specific constants
321 >             {
322 >                 strcpy(kv1,torkn1.kv[j]);
323 >                 if (strcmp(pt,kv1) == 0)
324 >                 {
325 >                     torsions.v1[i] = torkn1.tv1[j];
326 >                     torsions.ph1[i] = torkn1.phase1[j];    
327 >                     torsions.v2[i] = torkn1.tv2[j];
328 >                     torsions.ph2[i] = torkn1.phase2[j];    
329 >                     torsions.v3[i] = torkn1.tv3[j];
330 >                     torsions.ph3[i] = torkn1.phase3[j];    
331 >                     torsions.v4[i] = torkn1.tv4[j];
332 >                     torsions.ph4[i] = torkn1.phase4[j];    
333 >                     torsions.v5[i] = torkn1.tv5[j];
334 >                     torsions.ph5[i] = torkn1.phase5[j];    
335 >                     torsions.v6[i] = torkn1.tv6[j];
336 >                     torsions.ph6[i] = torkn1.phase6[j];
337 >                     goto L_10;
338 >                 }
339 >             }
340 >             for(j=0; j < torkn1.ntor; j++)  //  class 2
341 >             {
342 >                 strcpy(kv1,torkn1.kv[j]);
343 >                 if (strcmp(k2,kv1) == 0 || strcmp(k3,kv1) == 0 )
344 >                 {
345 >                     torsions.v1[i] = torkn1.tv1[j];
346 >                     torsions.ph1[i] = torkn1.phase1[j];    
347 >                     torsions.v2[i] = torkn1.tv2[j];
348 >                     torsions.ph2[i] = torkn1.phase2[j];    
349 >                     torsions.v3[i] = torkn1.tv3[j];
350 >                     torsions.ph3[i] = torkn1.phase3[j];    
351 >                     torsions.v4[i] = torkn1.tv4[j];
352 >                     torsions.ph4[i] = torkn1.phase4[j];    
353 >                     torsions.v5[i] = torkn1.tv5[j];
354 >                     torsions.ph5[i] = torkn1.phase5[j];    
355 >                     torsions.v6[i] = torkn1.tv6[j];
356 >                     torsions.ph6[i] = torkn1.phase6[j];
357 >                     goto L_10;
358 >                 }
359 >             }
360 >             for(j=0; j < torkn1.ntor; j++)  // wild cards
361 >             {
362 >                 strcpy(kv1,torkn1.kv[j]);
363 >                 if (strcmp(k5,kv1) == 0 || strcmp(k6,kv1) == 0 || strcmp(k7,kv1) == 0 || strcmp(k8,kv1) == 0 )
364 >                 {
365 >                     torsions.v1[i] = torkn1.tv1[j];
366 >                     torsions.ph1[i] = torkn1.phase1[j];    
367 >                     torsions.v2[i] = torkn1.tv2[j];
368 >                     torsions.ph2[i] = torkn1.phase2[j];    
369 >                     torsions.v3[i] = torkn1.tv3[j];
370 >                     torsions.ph3[i] = torkn1.phase3[j];    
371 >                     torsions.v4[i] = torkn1.tv4[j];
372 >                     torsions.ph4[i] = torkn1.phase4[j];    
373 >                     torsions.v5[i] = torkn1.tv5[j];
374 >                     torsions.ph5[i] = torkn1.phase5[j];    
375 >                     torsions.v6[i] = torkn1.tv6[j];
376 >                     torsions.ph6[i] = torkn1.phase6[j];
377 >                     goto L_10;
378 >                 }
379 >             }
380 >         }              
381 > // check regular specific parameters
382 >         for(j=0; j < torkn1.ntor; j++)
383 >         {
384 >             strcpy(kv1,torkn1.kv[j]);
385 >             if (strcmp(pt,kv1) == 0)
386 >             {
387 >               torsions.v1[i] = torkn1.tv1[j];
388 >               torsions.ph1[i] = torkn1.phase1[j];    
389 >               torsions.v2[i] = torkn1.tv2[j];
390 >               torsions.ph2[i] = torkn1.phase2[j];    
391 >               torsions.v3[i] = torkn1.tv3[j];
392 >               torsions.ph3[i] = torkn1.phase3[j];    
393 >               torsions.v4[i] = torkn1.tv4[j];
394 >               torsions.ph4[i] = torkn1.phase4[j];    
395 >               torsions.v5[i] = torkn1.tv5[j];
396 >               torsions.ph5[i] = torkn1.phase5[j];    
397 >               torsions.v6[i] = torkn1.tv6[j];
398 >               torsions.ph6[i] = torkn1.phase6[j];
399 > // check for pi torsions = mm3 does not define pitorsion parameter so we need to pick it up here
400 >               if (itb == 2 && itc == 2 && field.type == MMX)
401 >               {
402 >                   for (k=0; k < MAXIAT; k++)
403 >                   {
404 >                       if (atom[ib].iat[k] == ic)
405 >                       {
406 >                           if (atom[ib].bo[k] == 1 && is_delocalbond(ib,ic) )
407 >                           {
408 >                               torsions.v1[i] = 0.5;
409 >                               torsions.v2[i] = 1.0;
410 >                               torsions.v3[i] = 0.0;
411 >                               ierr = TRUE;
412 >                               goto L_10;
413 >                               break;
414 >                           }
415 >                       }
416 >                   }
417 >               }
418 >               goto L_10;
419 >               break;
420 >             }  
421 >          }
422 > // check regular generalized parameters
423 >         for(j=0; j < torkn1.ntor; j++)
424 >         {
425 >             strcpy(kv1,torkn1.kv[j]);
426 >             if (strcmp(pt,kv1) == 0 || strcmp(k1,kv1) == 0 || strcmp(k2,kv1) == 0 || strcmp(k3,kv1) == 0 ||      
427 >                 strcmp(k4,kv1) == 0 || strcmp(k5,kv1) == 0 || strcmp(k6,kv1) == 0 || strcmp(k7,kv1) == 0 ||      
428 >                 strcmp(k8,kv1) == 0 || strcmp(k9,kv1) == 0 || strcmp(k10,kv1) == 0 || strcmp(k11,kv1) == 0 ||      
429 >                 strcmp(k12,kv1) == 0 || strcmp(k13,kv1) == 0 || strcmp(k14,kv1) == 0 || strcmp(k15,kv1) == 0)
430 >             {
431 >               torsions.v1[i] = torkn1.tv1[j];
432 >               torsions.ph1[i] = torkn1.phase1[j];    
433 >               torsions.v2[i] = torkn1.tv2[j];
434 >               torsions.ph2[i] = torkn1.phase2[j];    
435 >               torsions.v3[i] = torkn1.tv3[j];
436 >               torsions.ph3[i] = torkn1.phase3[j];    
437 >               torsions.v4[i] = torkn1.tv4[j];
438 >               torsions.ph4[i] = torkn1.phase4[j];    
439 >               torsions.v5[i] = torkn1.tv5[j];
440 >               torsions.ph5[i] = torkn1.phase5[j];    
441 >               torsions.v6[i] = torkn1.tv6[j];
442 >               torsions.ph6[i] = torkn1.phase6[j];
443 > // check for pi torsions = mm3 does not define pitorsion parameter so we need to pick it up here
444 >               if (itb == 2 && itc == 2 && field.type == MMX)
445 >               {
446 >                   for (k=0; k < MAXIAT; k++)
447 >                   {
448 >                       if (atom[ib].iat[k] == ic)
449 >                       {
450 >                           if (atom[ib].bo[k] == 1 && is_delocalbond(ib,ic) )
451 >                           {
452 >                               torsions.v1[i] = 0.5;
453 >                               torsions.v2[i] = 1.0;
454 >                               torsions.v3[i] = 0.0;
455 >                               ierr = TRUE;
456 >                               goto L_10;
457 >                               break;
458 >                           }
459 >                       }
460 >                   }
461 >               }
462 >               goto L_10;
463 >               break;
464 >             }  
465 >          }
466 > //  missing parameters
467 >          if (ierr == FALSE)
468 >          {
469 > //              Missing_constants = TRUE;
470 >            fprintf(pcmlogfile,"Torsion constants missing: angle: %d %d %d %d  types: %d %d %d %d\n",ia,ib,ic,id,
471 >                      ita, itb, itc, itd);
472 >          }
473 > L_10:
474 >    continue;
475 >    }
476 >
477 >    if (allene.nallene > 0)
478 >    {
479 >        for (i = 0; i < allene.nallene; i++)
480 >        {
481 >            torsions.v1[allene.ntor[i]] = 0;
482 >            torsions.v2[allene.ntor[i]] = -11.5;
483 >            torsions.v3[allene.ntor[i]] = 0;
484 >        }
485 >    }
486 > }
487 > /*  --------------------------------------------   */
488 > void four(char *pa, char *pb, char *pc, char *pd, char *pt)
489 > {
490 >        strcpy(pt,pa);
491 >        strcat(pt,pb);
492 >        strcat(pt,pc);
493 >        strcat(pt,pd);
494 > }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines