ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/freemol/trunk/src/mengine/src/rings.c
(Generate patch)
# Line 1 | Line 1
1   #define EXTERN extern
2  
3   #include "pcwin.h"
4 #include "pcmod.h"
5
6 #include "angles.h"
7 #include "torsions.h"
4   #include "rings.h"
5 + #include "utility.h"
6  
7 <
7 > int have_ring3(void);
8 > int have_ring4(void);
9 > int have_ring5(void);
10 > int have_ring6(void);
11   int isbond(int, int);
12 int isangle(int,int);
12   int is_ring31(int);
13   int is_ring41(int);
14   int is_ring42(int,int);
# Line 24 | Line 23
23   int is_ring62(int, int);
24   int is_ring63(int,int,int);
25   int is_ring66(int *);
26 + int is_cyclo5(int, int *);
27   void ksort(int, int *);
28   void message_alert(char *, char *);
29   int is_cyclo6(int, int *);
30 + int find_rsize(int, int);
31 + void get_rsize(int,int,int,int *);
32 + int aromatic_5(int *array,long int *flags,int *atomnum,int **,int **);
33 + int aromatic_6(int *,long int *flags,int *atomnum,int **,int **);
34 + void get_rings(int natom,long int *flags,int *atomnum,int **iat,int **bo);
35 + void allocate_rings(int niatom);
36 + int check_ring1(int);
37  
38 + // ===========================
39 + void allocate_rings(int niatom)
40 + {
41 +  rings.nring3 = 0;
42 +  rings.nring4 = 0;
43 +  rings.nring5 = 0;
44 +  rings.nring6 = 0;
45 +  rings.r13 = imatrix(0,(niatom+10)/3, 0,3);
46 +  rings.r14 = imatrix(0,(niatom+10)/4, 0,4);
47 +  rings.r15 = imatrix(0,(niatom+10)/5, 0,5);
48 +  rings.r16 = imatrix(0,(niatom+10)/2, 0,6);
49 + }
50 + // ======================
51 + int have_ring3()
52 + {
53 +  if (rings.nring3 > 0)
54 +    return TRUE;
55 +  else
56 +    return FALSE;
57 + }
58 + int have_ring4()
59 + {
60 +  if (rings.nring4 > 0)
61 +    return TRUE;
62 +  else
63 +    return FALSE;
64 + }
65 + int have_ring5()
66 + {
67 +  if (rings.nring5 > 0)
68 +    return TRUE;
69 +  else
70 +    return FALSE;
71 + }
72 + int have_ring6()
73 + {
74 +  if (rings.nring6 > 0)
75 +    return TRUE;
76 +  else
77 +    return FALSE;
78 + }
79 + /* --------------------------------------------------------- */
80 + // iatom is atom number to search on
81 + // isize = ring size
82 + // num = number of ring if more than one ring containing atom iatom
83 + // array = array of ring atoms
84 + //
85 + void get_rsize(int iatom, int isize, int num, int *array)
86 + {
87 +    int i, j, k, icount;
88 +    icount = -1;
89 +    
90 +    if (isize == 3)
91 +    {
92 +       for (i=0; i < rings.nring3; i++)
93 +       {
94 +           for (j=0; j < 3; j++)
95 +           {
96 +               if (iatom == rings.r13[i][j])
97 +                  icount++;
98 +               if (icount == num)
99 +               {
100 +                  for (k=0; k < isize; k++)
101 +                      array[k] = rings.r13[i][k];
102 +                  return;
103 +               }
104 +           }
105 +        }
106 +    } else if (isize == 4)
107 +    {
108 +       for (i=0; i < rings.nring4; i++)
109 +       {
110 +           for (j=0; j < 4; j++)
111 +           {
112 +               if (iatom == rings.r14[i][j])
113 +                  icount++;
114 +               if (icount == num)
115 +               {
116 +                  for (k=0; k < isize; k++)
117 +                      array[k] = rings.r14[i][k];
118 +                  return;
119 +               }
120 +           }
121 +        }
122 +    } else if (isize == 5)
123 +    {
124 +       for (i=0; i < rings.nring5; i++)
125 +       {
126 +           for (j=0; j < 5; j++)
127 +           {
128 +               if (iatom == rings.r15[i][j])
129 +                  icount++;
130 +               if (icount == num)
131 +               {
132 +                  for (k=0; k < isize; k++)
133 +                      array[k] = rings.r15[i][k];
134 +                  return;
135 +               }
136 +           }
137 +        }
138 +    } else if (isize == 6)
139 +    {
140 +       for (i=0; i < rings.nring6; i++)
141 +       {
142 +           for (j=0; j < 6; j++)
143 +           {
144 +               if (iatom == rings.r16[i][j])
145 +                  icount++;
146 +               if (icount == num)
147 +               {
148 +                  for (k=0; k < isize; k++)
149 +                      array[k] = rings.r16[i][k];
150 +                  return;
151 +               }
152 +           }
153 +        }
154 +    }
155 + }
156 + /* --------------------------------------------------------- */
157 + int find_rsize(int isize,int iatom)
158 + {
159 +    int i, j, icount;
160 +    
161 +    icount = 0;
162 +    if (isize == 3)
163 +    {
164 +        for (i=0; i < rings.nring3; i++)
165 +        {
166 +            for(j=0; j < 3; j++)
167 +            {
168 +                if (rings.r13[i][j] == iatom)
169 +                    icount++;
170 +            }
171 +        }
172 +        return(icount);
173 +    }else if (isize == 4)
174 +    {
175 +        for (i=0; i < rings.nring4; i++)
176 +        {
177 +            for(j=0; j < 4; j++)
178 +            {
179 +                if (rings.r14[i][j] == iatom)
180 +                    icount++;
181 +            }
182 +        }
183 +        return(icount);
184 +    }else if (isize == 5)
185 +    {
186 +        for (i=0; i < rings.nring5; i++)
187 +        {
188 +            for(j=0; j < 5; j++)
189 +            {
190 +                if (rings.r15[i][j] == iatom)
191 +                    icount++;
192 +            }
193 +        }
194 +        return(icount);
195 +    }else if (isize == 6)
196 +    {
197 +        for (i=0; i < rings.nring6; i++)
198 +        {
199 +            for(j=0; j < 6; j++)
200 +            {
201 +                if (rings.r16[i][j] == iatom)
202 +                    icount++;
203 +            }
204 +        }
205 +        return(icount);
206 +    }
207 +    return(icount);
208 + }
209 + // =======================
210   int is_ring31(int ia)
211   {
212      int i,j;
# Line 157 | Line 336
336      }
337      return(FALSE);
338   }
339 + // ======================================
340 + int is_cyclo5(int ia, int *array)
341 + {
342 +    int i,j;
343 +
344 +    for(i=0; i < rings.nring5; i++)
345 +    {
346 +        for (j=0; j < 5; j++)
347 +        {
348 +            if (rings.r15[i][j] == ia)
349 +            {
350 +              array[0] = rings.r15[i][0];
351 +              array[1] = rings.r15[i][1];
352 +              array[2] = rings.r15[i][2];
353 +              array[3] = rings.r15[i][3];
354 +              array[4] = rings.r15[i][4];
355 +              return(TRUE);
356 +            }
357 +        }
358 +    }
359 +    return(FALSE);
360 + }
361   /* -------------------------------------------------------- */
362   int is_ring52(int ia, int ib)
363   {
# Line 354 | Line 555
555      return (FALSE);
556   }
557   /* -------------------------------------------------------- */    
558 <
358 < void get_rings()
558 > void get_rings(int natom,long int *flags,int *atomnum,int **iat,int **bo)
559   {
560 <   int i,j, add_ring, k, l;
561 <   int jatm,katm;
560 >  int i,j, add_ring, k, l, m, n,ij,isix;
561 >   int jatm,katm,latm,matm,xatm;
562     int array[6];
563 +   long int aromatic_mask;
564  
565     rings.nring3 = 0;
566     rings.nring4 = 0;
567     rings.nring5 = 0;
568     rings.nring6 = 0;
569 +    aromatic_mask = (1L << AROMATIC_MASK);
570  
571   // get three membered rings
572 <   for (i=0; i < angles.nang; i++)
573 <   {
574 <       if (isbond(angles.i13[i][0], angles.i13[i][2]))
575 <       {
576 <           array[0] = angles.i13[i][0];
577 <           array[1] = angles.i13[i][1];
578 <           array[2] = angles.i13[i][2];
579 <           ksort(3, array);
580 <           add_ring = TRUE;
581 <           for (j = 0; j < rings.nring3; j++)
582 <           {
583 <               if (array[0] == rings.r13[j][0] && array[1] == rings.r13[j][1]
584 <                 && array[2] == rings.r13[j][2])
585 <               {
586 <                   add_ring = FALSE;
587 <                   break;
588 <               }
589 <           }
590 <           if (add_ring == TRUE)
591 <           {                              
592 <              rings.r13[rings.nring3][0] = array[0];
593 <              rings.r13[rings.nring3][1] = array[1];
594 <              rings.r13[rings.nring3][2] = array[2];
595 <              rings.nring3++;
596 <           }
597 <       }
598 <   }
572 >   for (i=1; i <= natom; i++)
573 >     {
574 >       for (j=0; j < MAXIAT; j++)
575 >         {
576 >           if (iat[i][j] != 0)
577 >             {
578 >               jatm = iat[i][j];
579 >               for (k=0; k < MAXIAT; k++)
580 >                 {
581 >                   if (iat[jatm][k] != 0 && iat[jatm][k] != i)
582 >                     {
583 >                       if (isbond(i,iat[jatm][k]))
584 >                         {
585 >                           array[0] = i;
586 >                           array[1] = jatm;
587 >                           array[2] = iat[jatm][k];
588 >                           ksort(3,array);
589 >                           add_ring = TRUE;
590 >                           for (j = 0; j < rings.nring3; j++)
591 >                             {
592 >                               if (array[0] == rings.r13[j][0] && array[1] == rings.r13[j][1]
593 >                                   && array[2] == rings.r13[j][2])
594 >                                 {
595 >                                   add_ring = FALSE;
596 >                                   break;
597 >                                 }
598 >                             }
599 >                           if (add_ring == TRUE)
600 >                             {                              
601 >                               rings.r13[rings.nring3][0] = array[0];
602 >                               rings.r13[rings.nring3][1] = array[1];
603 >                               rings.r13[rings.nring3][2] = array[2];
604 >                               rings.nring3++;
605 >                               if (rings.nring3 >= MAXATOM/3)
606 >                                  message_alert("Error. Too many 3 membered rings!","ERROR");
607 >                             }
608 >                         }
609 >                     }
610 >                 }
611 >             }
612 >         }
613 >     }
614   // get four membered rings
615     for(i=1; i <= natom; i++)
616     {
617         for(j=0; j < MAXIAT; j++)
618         {
619 <           if (atom[i].iat[j] != 0 && atom[i].bo[j] != 9)
619 >           if (iat[i][j] != 0)
620             {
621 <               jatm = atom[i].iat[j];
621 >               jatm = iat[i][j];
622                 for (k=0; k < MAXIAT; k++)
623                 {
624 <                   if (atom[jatm].iat[k] != 0 && atom[jatm].bo[k] != 9 && atom[jatm].iat[k] != i)
624 >                   if (iat[jatm][k] != 0 && iat[jatm][k] != i)
625                     {
626 <                       katm = atom[jatm].iat[k];
626 >                       katm = iat[jatm][k];
627                         if (!(isbond(katm,i)))
628                         {
629                             for(l=0; l < MAXIAT; l++)
630                             {
631 <                               if (atom[katm].iat[l] != 0 && atom[katm].bo[l] != 9 && atom[katm].iat[l] != jatm)
631 >                               if (iat[katm][l] != 0 && iat[katm][l] != jatm)
632                                 {
633 <                                   if (isbond(i,atom[katm].iat[l]) )
633 >                                   if (isbond(i,iat[katm][l]) )
634                                     {
635                                          array[0] = i;
636                                          array[1] = jatm;
637                                          array[2] = katm;
638 <                                        array[3] = atom[katm].iat[l];
638 >                                        array[3] = iat[katm][l];
639                                          ksort(4, array);
640                                          if ( is_ring44(array) == FALSE )
641                                          {          
# Line 427 | Line 644
644                                            rings.r14[rings.nring4][2] = array[2];
645                                            rings.r14[rings.nring4][3] = array[3];
646                                            rings.nring4++;
647 +                                          if (rings.nring4 >= MAXATOM/4)
648 +                                              message_alert("Error. Too many 4 membered rings!","ERROR");
649                                          }
650                                     }
651                                 }
# Line 437 | Line 656
656             }
657         }
658     }
659 < // get five membered rings
660 <   for(i=0; i < torsions.ntor; i++)
659 > // get five membered rings i-jatm-katm-latm-
660 >   for(i=1; i <= natom; i++)
661     {
662 <      if (!isbond(torsions.i14[i][0],torsions.i14[i][3]))
663 <      {
664 <        for (j=0; j < MAXIAT; j++)
665 <        {
666 <          jatm = atom[torsions.i14[i][0]].iat[j];
667 <          if ( jatm != torsions.i14[i][1] && jatm != torsions.i14[i][2] && jatm != torsions.i14[i][3] )
668 <          {
669 <              if (isbond(jatm,torsions.i14[i][3]))
670 <              {
671 <                array[0] = jatm;
672 <                array[1] = torsions.i14[i][0];
673 <                array[2] = torsions.i14[i][1];
674 <                array[3] = torsions.i14[i][2];
675 <                array[4] = torsions.i14[i][3];
676 <                ksort(5,array);
677 <                if ( is_ring55(array) == FALSE )
678 <                {              
679 <                   rings.r15[rings.nring5][0] = array[0];
680 <                   rings.r15[rings.nring5][1] = array[1];
681 <                   rings.r15[rings.nring5][2] = array[2];
682 <                   rings.r15[rings.nring5][3] = array[3];
683 <                   rings.r15[rings.nring5][4] = array[4];
684 <                   rings.nring5++;
685 <                   if (rings.nring5 >= natom)
686 <                       message_alert("Error. Too many 5 membered rings!","ERROR");
687 <                      
688 <                }
689 <             }
690 <          }
691 <        }
692 <      }
662 >       for(j=0; j < MAXIAT; j++)
663 >       {
664 >           if (iat[i][j] != 0)
665 >           {
666 >               jatm = iat[i][j];
667 >               for (k=0; k < MAXIAT; k++)
668 >               {
669 >                   if (iat[jatm][k] != 0 && iat[jatm][k] != i)
670 >                   {
671 >                       katm = iat[jatm][k];
672 >                       if (!(isbond(katm,i)))
673 >                       {
674 >                           for(l=0; l < MAXIAT; l++)
675 >                           {
676 >                               if (iat[katm][l] != 0 && iat[katm][l] != jatm)
677 >                               {
678 >                                 latm = iat[katm][l];
679 >                                 for (m=0; m < MAXIAT; m++)
680 >                                   {
681 >                                     if (iat[latm][m] != 0 && iat[latm][m] != katm && iat[latm][m] != jatm)
682 >                                       {
683 >                                         if (isbond(i,iat[latm][m]))
684 >                                           {
685 >                                             array[0] = i;
686 >                                             array[1] = jatm;
687 >                                             array[2] = katm;
688 >                                             array[3] = latm;
689 >                                             array[4] = iat[latm][m];
690 >                                             ksort(5,array);
691 >                                             if (is_ring55(array) == FALSE)
692 >                                               {
693 >                                                 rings.r15[rings.nring5][0] = array[0];
694 >                                                 rings.r15[rings.nring5][1] = array[1];
695 >                                                 rings.r15[rings.nring5][2] = array[2];
696 >                                                 rings.r15[rings.nring5][3] = array[3];
697 >                                                 rings.r15[rings.nring5][4] = array[4];
698 >                                                 rings.nring5++;
699 >                                                 if (rings.nring5 >= MAXATOM/5)
700 >                                                   message_alert("Error. Too many 5 membered rings!","ERROR");
701 >                                                 isix = aromatic_5(array,flags,atomnum,iat,bo);
702 >                                                 if (isix == TRUE)
703 >                                                   {
704 >                                                      for (ij = 0; ij < 5; ij++)
705 >                                                         flags[array[ij]] |= aromatic_mask;
706 >                                                   }
707 >                                               }
708 >                                           }
709 >                                       }
710 >                                   }
711 >                               }
712 >                           }
713 >                       }
714 >                   }
715 >               }
716 >           }
717 >       }
718     }
719   // get six membered rings
720 <   for(i=0; i <= natom; i++)
720 >   for(i=1; i <= natom; i++)
721     {
722 <       if (atom[i].type != 5 && atom[i].type != 20)
722 >       for(j=0; j < MAXIAT; j++)
723         {
724 <           if (is_cyclo6(i, array))
724 >           if (iat[i][j] != 0)
725             {
726 <              ksort(6,array);
727 <              if (is_ring66(array) == FALSE)
728 <              {
729 <                  rings.r16[rings.nring6][0] = array[0];
730 <                  rings.r16[rings.nring6][1] = array[1];
731 <                  rings.r16[rings.nring6][2] = array[2];
732 <                  rings.r16[rings.nring6][3] = array[3];
733 <                  rings.r16[rings.nring6][4] = array[4];
734 <                  rings.r16[rings.nring6][5] = array[5];
735 <                  rings.nring6++;
736 <                  if (rings.nring6 >= natom)
737 <                          message_alert("Error. Too many 6 membered rings!","ERROR");
738 <              }
739 <           }  
726 >               jatm = iat[i][j];
727 >               for (k=0; k < MAXIAT; k++)
728 >               {
729 >                   if (iat[jatm][k] != 0 && iat[jatm][k] != i)
730 >                   {
731 >                       katm = iat[jatm][k];
732 >                       if (!(isbond(katm,i)))
733 >                       {
734 >                           for(l=0; l < MAXIAT; l++)
735 >                           {
736 >                               if (iat[katm][l] != 0 && iat[katm][l] != jatm)
737 >                               {
738 >                                 latm = iat[katm][l];
739 >                                 for (m=0; m < MAXIAT; m++)
740 >                                   {
741 >                                     if (iat[latm][m] != 0 && iat[latm][m] != katm && iat[latm][m] != jatm)
742 >                                       {
743 >                                         xatm = iat[latm][m];
744 >                                         for (n = 0; n < MAXIAT; n++)
745 >                                           {
746 >                                             if (iat[xatm][n] != 0 && iat[xatm][n] != latm && iat[xatm][n] != katm)
747 >                                               if (isbond(i,iat[xatm][n]))
748 >                                                 {
749 >                                                   array[0] = i;
750 >                                                   array[1] = jatm;
751 >                                                   array[2] = katm;
752 >                                                   array[3] = latm;
753 >                                                   array[4] = xatm;
754 >                                                   array[5] = iat[xatm][n];
755 >                                                   ksort(6,array);
756 >                                                   if (is_ring66(array) == FALSE)
757 >                                                     {
758 >                                                       rings.r16[rings.nring6][0] = array[0];
759 >                                                       rings.r16[rings.nring6][1] = array[1];
760 >                                                       rings.r16[rings.nring6][2] = array[2];
761 >                                                       rings.r16[rings.nring6][3] = array[3];
762 >                                                       rings.r16[rings.nring6][4] = array[4];
763 >                                                       rings.r16[rings.nring6][5] = array[5];
764 >                                                       rings.nring6++;
765 >                                                       if (rings.nring6 >= MAXATOM/6)
766 >                                                         message_alert("Error. Too many 6 membered rings!","ERROR");
767 >                                                       isix = aromatic_6(array,flags,atomnum,iat,bo);
768 >                                                       if (isix == TRUE)
769 >                                                         {
770 >                                                           for (ij = 0; ij < 6; ij++)
771 >                                                             flags[array[ij]] |= aromatic_mask;
772 >                                                         }
773 >                                                     }
774 >                                                 }
775 >                                           }
776 >                                       }
777 >                                   }
778 >                               }
779 >                           }
780 >                       }
781 >                   }
782 >               }
783 >           }
784         }
785     }
498  
499 /*   if (rings.nring3 != 0)
500      printf("Number of three membered rings: %d\n",rings.nring3);
501   if (rings.nring4 != 0)
502      printf("Number of four membered rings: %d\n",rings.nring4);
503   if (rings.nring5 != 0)
504      printf("Number of five membered rings: %d\n",rings.nring5);
505   if (rings.nring6 != 0)
506      printf("Number of six membered rings: %d\n",rings.nring6); */
507      
786   }
787   /* =================================================== */
788   void ksort(int num, int array[])
# Line 527 | Line 805
805      if (found == TRUE)
806         goto L_1;
807   }
808 + /* --------------------------------------------------------- */
809 + int aromatic_5(int *array,long int *flags,int *atomnum,int **iat,int **bo)
810 + {
811 +    int i,j,k, jatm, katm;
812 +    int nodbl, npi;
813 +    int ia, ib, ic;
814 +    int db[10];
815 +    int ihetero;
816 +    long int aromatic_mask, mask6;
817 +
818 +    aromatic_mask = (1 << AROMATIC_MASK);
819 +    mask6 = (1L << RING6);
820 +    
821 +    npi = 0;
822 +    ihetero = 0;
823 +    for (i=0; i < 4; i++)
824 +    {
825 +        jatm = array[i];
826 +        for (j=i+1;j < 5; j++)
827 +        {
828 +            katm = array[j];
829 +            if (isbond(jatm,katm))
830 +            {
831 +                for (k=0; k < MAXIAT; k++)
832 +                {
833 +                    if (iat[jatm][k] == katm)
834 +                    {
835 +                        if (bo[jatm][k] == 2)
836 +                        {
837 +                            db[npi] = i+j;
838 +                            npi++;
839 +                        }else if ( (flags[jatm] & aromatic_mask && flags[jatm] & mask6 )
840 +                                 && (flags[katm] & aromatic_mask && flags[katm] & mask6 ))
841 +                        {
842 +                            db[npi] = i+j;
843 +                            npi++;
844 +                        }
845 +                    }
846 +                }
847 +            }
848 +        }
849 +    }                    
850 +    for (i=0; i < 5; i++)
851 +    {
852 +        jatm = array[i];
853 +        if (atomnum[jatm] != 6)
854 +        {
855 +            nodbl = FALSE;
856 +            for(j=0; j < MAXIAT; j++)
857 +            {
858 +                if (iat[jatm][j] != 0)
859 +                {
860 +                    if (bo[jatm][j] > 1 && bo[jatm][j] != 9)
861 +                       nodbl = TRUE;
862 +                }
863 +            }
864 +            if (nodbl == FALSE)
865 +               ihetero = jatm;
866 +        }
867 +    }
868 +    if (npi >= 2 && ihetero != 0)   // got an aromatic ring with heteroatom
869 +       return TRUE;            
870 +
871 +    if (npi == 0)                   // no double bonds in ring
872 +       return FALSE;
873 +
874 +    if (npi == 1 && ihetero == 0)
875 +       return FALSE;
876 +
877 +    if (npi == 1)
878 +    {
879 +        if (db[0] == 1)
880 +        {
881 +            ia = array[2];
882 +            ib = array[3];
883 +            ic = array[4];
884 +        } else if (db[0] == 3)
885 +        {
886 +            ia = array[0];
887 +            ib = array[3];
888 +            ic = array[4];
889 +        } else if (db[0] == 4)
890 +        {
891 +            ia = array[1];
892 +            ib = array[2];
893 +            ic = array[3];
894 +        } else if (db[0] == 5)
895 +        {
896 +            ia = array[0];
897 +            ib = array[1];
898 +            ic = array[4];
899 +        } else if (db[0] == 7)
900 +        {
901 +            ia = array[0];
902 +            ib = array[1];
903 +            ic = array[2];
904 +        }
905 +        if (ia == ihetero)
906 +        {
907 +           for(i=0; i < rings.nring6; i++)
908 +           {
909 +              for (j=0; j < 6; j++)
910 +              {
911 +                 if (rings.r16[i][j] == ib)
912 +                 {
913 +                     if (flags[ib] & aromatic_mask)
914 +                       return TRUE;
915 +                 }
916 +                 if (rings.r16[i][j] == ic)
917 +                 {
918 +                     if (flags[ic] & aromatic_mask)
919 +                       return TRUE;
920 +                 }
921 +              }
922 +           }
923 +        } else if (ib == ihetero)
924 +        {
925 +           for(i=0; i < rings.nring6; i++)
926 +           {
927 +              for (j=0; j < 6; j++)
928 +              {
929 +                 if (rings.r16[i][j] == ia)
930 +                 {
931 +                     if (flags[ia] & aromatic_mask)
932 +                       return TRUE;
933 +                 }
934 +                 if (rings.r16[i][j] == ic)
935 +                 {
936 +                     if (flags[ic] & aromatic_mask)
937 +                       return TRUE;
938 +                 }
939 +              }
940 +           }
941 +        } else if (ic == ihetero)
942 +        {
943 +           for(i=0; i < rings.nring6; i++)
944 +           {
945 +              for (j=0; j < 6; j++)
946 +              {
947 +                 if (rings.r16[i][j] == ib)
948 +                 {
949 +                     if (flags[ib] & aromatic_mask)
950 +                       return TRUE;
951 +                 }
952 +                 if (rings.r16[i][j] == ia)
953 +                 {
954 +                     if (flags[ia] & aromatic_mask)
955 +                       return TRUE;
956 +                 }
957 +              }
958 +           }
959 +        }
960 +    }
961 +    return FALSE;                  
962 + }
963 + /* --------------------------------------------------------- */
964 + int aromatic_6(int *array,long int *flags,int *atomnum,int **iat,int **bo)
965 + {
966 +    int i,j,k, ia,ib, idbl,kdbl;
967 +    int num, inarray[10];
968 +    long int aromatic_mask, mask6;
969 +
970 +    aromatic_mask = (1 << AROMATIC_MASK);
971 +    mask6 = (1L << RING6);
972 +    num = 0;
973 +    for (i=0; i < 10; i++)
974 +       inarray[i] = FALSE;
975 +      
976 +    for (i=0; i < 5; i++)
977 +    {
978 +        ia = array[i];
979 +        for (j=i+1; j < 6; j++)
980 +        {
981 +            for (k=0; k < MAXIAT; k++)
982 +            {
983 +                if (iat[ia][k] == array[j])
984 +                {
985 +                    if (bo[ia][k] == 2)
986 +                    {
987 +                       num++;
988 +                       inarray[i] = TRUE;
989 +                       inarray[j] = TRUE;
990 +                    }
991 +                }
992 +            }
993 +        }
994 +    }
995 +    if (num == 3)
996 +      return TRUE;
997 +
998 +    if (num >= 1)
999 +    {
1000 +        for(i=0; i < 5; i++)
1001 +        {
1002 +            if (inarray[i] == FALSE)
1003 +            {
1004 +                ia = array[i];
1005 +                for(j=i+1;j < 6; j++)
1006 +                {
1007 +                    if (inarray[j] == FALSE)
1008 +                    {
1009 +                        ib = array[j];
1010 +                        if ( (flags[ia] & aromatic_mask) && (flags[ib] & aromatic_mask))
1011 +                        {
1012 +                           num++;
1013 +                           if (num == 3)
1014 +                              return TRUE;
1015 +                        } else if (isbond(ia,ib))
1016 +                        {
1017 +                           idbl = FALSE;
1018 +                           kdbl = FALSE;
1019 +                           for(k=0; k < MAXIAT; k++)
1020 +                           {
1021 +                              if (iat[ia][k] !=0 && bo[ia][k] == 2)
1022 +                              {
1023 +                                 if (atomnum[iat[ia][k]] == 6 || atomnum[iat[ia][k]] == 7)
1024 +                                 {
1025 +                                     if (flags[iat[ia][k]] & mask6)
1026 +                                         idbl = TRUE;
1027 +                                 }
1028 +                              }
1029 +                              if (iat[ib][k] !=0 && bo[ib][k] == 2)
1030 +                              {
1031 +                                 if (atomnum[iat[ib][k]] == 6 || atomnum[iat[ib][k]] == 7)
1032 +                                 {
1033 +                                     if (flags[iat[ib][k]] & mask6)
1034 +                                         kdbl = TRUE;
1035 +                                 }
1036 +                              }
1037 +                           }
1038 +                           if (idbl == TRUE && kdbl == TRUE)
1039 +                           {
1040 +                               num++;
1041 +                               if (num == 3)
1042 +                                  return TRUE;
1043 +                           }
1044 +                        }
1045 +                        inarray[i] = TRUE;
1046 +                        inarray[j] = TRUE;
1047 +                    }
1048 +                }
1049 +            }
1050 +        }
1051 +    }
1052 +    return FALSE;
1053 + }
1054 + // ==================================
1055 + int check_ring1(int ia)
1056 + {
1057 +    if (is_ring61(ia)) return TRUE;
1058 +    if (is_ring51(ia)) return TRUE;
1059 +    if (is_ring31(ia)) return TRUE;
1060 +    if (is_ring41(ia)) return TRUE;
1061 +    return FALSE;
1062 + }
1063  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines