ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/openbabel/residue.cpp
Revision: 751
Committed: Thu Nov 17 20:38:45 2005 UTC (19 years, 5 months ago) by gezelter
File size: 46032 byte(s)
Log Message: 
Unifying config.h stuff and making sure the OpenBabel codes can find
our default (and environment variable) Force Field directories.

File Contents

# User Rev Content
1 tim 741 /**********************************************************************
2     residue.cpp - Handle macromolecule residues.
3    
4     Copyright (C) 2001, 2002 OpenEye Scientific Software, Inc.
5     Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
6    
7     This file is part of the Open Babel project.
8     For more information, see <http://openbabel.sourceforge.net/>
9    
10     This program is free software; you can redistribute it and/or modify
11     it under the terms of the GNU General Public License as published by
12     the Free Software Foundation version 2 of the License.
13    
14     This program is distributed in the hope that it will be useful,
15     but WITHOUT ANY WARRANTY; without even the implied warranty of
16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17     GNU General Public License for more details.
18     ***********************************************************************/
19    
20     /**********************************************************************
21     Global arrays Residue, ElemDesc and function GetResidueNumber were
22     obtained in part or whole from RasMol2 by Roger Sayle.
23     ***********************************************************************/
24    
25     ///////////////////////////////////////////////////////////////////////////////
26     // File Includes
27     ///////////////////////////////////////////////////////////////////////////////
28    
29 gezelter 751 #include "config.h"
30 tim 741
31     #if HAVE_IOSTREAM
32     #include <iostream>
33     #elif HAVE_IOSTREAM_H
34     #include <iostream.h>
35     #endif
36    
37     #if HAVE_FSTREAM
38     #include <fstream>
39     #elif HAVE_FSTREAM_H
40     #include <fstream.h>
41     #endif
42    
43     #include "mol.hpp"
44     #include "bitvec.hpp"
45    
46     using namespace std;
47    
48     namespace OpenBabel
49     {
50     /** \class OBResidue
51     \brief Residue information
52    
53     The residue information is drawn from PDB or MOL2 files (or similar), which
54     track biomolecule information,
55     and are stored in the OBResidue class. OBResidues are stored inside the
56     OBAtom class and OBMol classes.
57     The residue information for an atom can be requested in
58     the following way:
59     \code
60     OBAtom *atom;
61     OBResidue *r;
62     atom = mol.GetAtom(1);
63     r = atom->GetResidue();
64     \endcode
65     The residue information for a molecule can be manipulated too:
66     \code
67     cout << "This molecule has " << mol.NumResidues() << " residues." << endl;
68     OBResidue *r;
69     r = mol.GetResidue(1);
70     \endcode
71     */
72    
73     ///////////////////////////////////////////////////////////////////////////////
74     // Global Definitions
75     ///////////////////////////////////////////////////////////////////////////////
76    
77     #define MAXSETNO 40
78     #define MAXELEM 1024
79     #define MINELEM 29
80     #define MAXRES 100
81     #define MINRES 54
82    
83     ///////////////////////////////////////////////////////////////////////////////
84     // Amino Acid Definitions
85     ///////////////////////////////////////////////////////////////////////////////
86    
87     #define AA_ALA (1<<1)
88     #define AA_GLY (1<<2)
89     #define AA_LEU (1<<3)
90     #define AA_SER (1<<4)
91     #define AA_VAL (1<<5)
92     #define AA_THR (1<<6)
93     #define AA_LYS (1<<7)
94     #define AA_ASP (1<<8)
95     #define AA_ILE (1<<9)
96     #define AA_ASN (1<<10)
97     #define AA_GLU (1<<11)
98     #define AA_PRO (1<<12)
99     #define AA_ARG (1<<13)
100     #define AA_PHE (1<<14)
101     #define AA_GLN (1<<15)
102     #define AA_TYR (1<<16)
103     #define AA_HIS (1<<17)
104     #define AA_CYS (1<<18)
105     #define AA_MET (1<<19)
106     #define AA_TRP (1<<20)
107    
108     //! Residue property definitions
109     namespace OBAminoAcidProperty
110     {
111     static const unsigned int ACIDIC = 0;
112     static const unsigned int ACYCLIC = 1;
113     static const unsigned int ALIPHATIC = 2;
114     static const unsigned int AROMATIC = 3;
115     static const unsigned int BASIC = 4;
116     static const unsigned int BURIED = 5;
117     static const unsigned int CHARGED = 6;
118     static const unsigned int CYCLIC = 7;
119     static const unsigned int HYDROPHOBIC = 8;
120     static const unsigned int LARGE = 9;
121     static const unsigned int MEDIUM = 10;
122     static const unsigned int NEGATIVE = 11;
123     static const unsigned int NEUTRAL = 12;
124     static const unsigned int POLAR = 13;
125     static const unsigned int POSITIVE = 14;
126     static const unsigned int SMALL = 15;
127     static const unsigned int SURFACE = 16;
128     }
129    
130     //! Residue atom properties
131     namespace OBResidueAtomProperty
132     {
133     static const unsigned int ALPHA_CARBON = 0;
134     static const unsigned int AMINO_BACKBONE = 1;
135     static const unsigned int BACKBONE = 2;
136     static const unsigned int CYSTEINE_SULPHUR = 3;
137     static const unsigned int LIGAND = 4;
138     static const unsigned int NUCLEIC_BACKBONE = 5;
139     static const unsigned int SHAPELY_BACKBONE = 6;
140     static const unsigned int SHAPELY_SPECIAL = 7;
141     static const unsigned int SIDECHAIN = 8;
142     static const unsigned int SUGAR_PHOSPHATE = 9;
143     }
144     /// Residue names
145     namespace OBResidueIndex
146     {
147     static const unsigned int ALA = 0;
148     static const unsigned int GLY = 1;
149     static const unsigned int LEU = 2;
150     static const unsigned int SER = 3;
151     static const unsigned int VAL = 4;
152     static const unsigned int THR = 5;
153     static const unsigned int LYS = 6;
154     static const unsigned int ASP = 7;
155     static const unsigned int ILE = 8;
156     static const unsigned int ASN = 9;
157     static const unsigned int GLU = 10;
158     static const unsigned int PRO = 11;
159     static const unsigned int ARG = 12;
160     static const unsigned int PHE = 13;
161     static const unsigned int GLN = 14;
162     static const unsigned int TYR = 15;
163     static const unsigned int HIS = 16;
164     static const unsigned int CYS = 17;
165     static const unsigned int MET = 18;
166     static const unsigned int TRP = 19;
167     static const unsigned int ASX = 20;
168     static const unsigned int GLX = 21;
169     static const unsigned int PCA = 22;
170     static const unsigned int HYP = 23;
171     static const unsigned int A = 24;
172     static const unsigned int C = 25;
173     static const unsigned int G = 26;
174     static const unsigned int T = 27;
175     static const unsigned int U = 28;
176     static const unsigned int UPLUS = 29;
177     static const unsigned int I = 30;
178     //static const unsigned int _1MA = 31;
179     //static const unsigned int _5MC = 32;
180     static const unsigned int OMC = 33;
181     //static const unsigned int _1MG = 34;
182     //static const unsigned int _2MG = 35;
183     static const unsigned int M2G = 36;
184     //static const unsigned int _7MG = 37;
185     static const unsigned int OMG = 38;
186     static const unsigned int YG = 39;
187     static const unsigned int H2U = 40;
188     //static const unsigned int _5MU = 41;
189     static const unsigned int PSU = 42;
190     static const unsigned int UNK = 43;
191     static const unsigned int ACE = 44;
192     static const unsigned int FOR = 45;
193     static const unsigned int HOH = 46;
194     static const unsigned int DOD = 47;
195     static const unsigned int SO4 = 48;
196     static const unsigned int PO4 = 49;
197     static const unsigned int NAD = 50;
198     static const unsigned int COA = 51;
199     static const unsigned int NAP = 52;
200     static const unsigned int NDP = 53;
201     }
202     /// Residue types.
203     namespace OBResidueProperty
204     {
205     static const unsigned int AMINO = 0;
206     static const unsigned int AMINO_NUCLEO = 1;
207     static const unsigned int COENZYME = 2;
208     static const unsigned int ION = 3;
209     static const unsigned int NUCLEO = 4;
210     static const unsigned int PROTEIN = 5;
211     static const unsigned int PURINE = 6;
212     static const unsigned int PYRIMIDINE = 7;
213     static const unsigned int SOLVENT = 8;
214     static const unsigned int WATER = 9;
215     }
216    
217     ///////////////////////////////////////////////////////////////////////////////
218     // Amino Acid Property Definitions
219     ///////////////////////////////////////////////////////////////////////////////
220    
221     #define IS_ACIDIC(x) ((x) & ((AA_ASP)|(AA_GLU)))
222     #define IS_ACYCLIC(x) ((x) & ((AA_ALA)|(AA_GLY)|(AA_LEU)|(AA_SER)| \
223     (AA_VAL)|(AA_THR)|(AA_LYS)|(AA_ASP)| \
224     (AA_ILE)|(AA_ASN)|(AA_GLU)|(AA_GLN)| \
225     (AA_CYS)|(AA_MET)))
226     #define IS_ALIPHATIC(x) ((x) & ((AA_ALA)|(AA_GLY)|(AA_ILE)|(AA_LEU)| \
227     (AA_VAL)))
228     #define IS_AROMATIC(x) ((x) & ((AA_HIS)|(AA_PHE)|(AA_TRP)|(AA_TYR)))
229     #define IS_BASIC(x) ((x) & ((AA_ARG)|(AA_HIS)|(AA_LYS)))
230     #define IS_BURIED(x) ((x) & ((AA_ALA)|(AA_CYS)|(AA_ILE)|(AA_LEU)| \
231     (AA_MET)|(AA_PHE)|(AA_TRP)|(AA_VAL)))
232     #define IS_CHARGED(x) ((x) & ((AA_ASP)|(AA_GLU)|(AA_ARG)|(AA_HIS)| \
233     (AA_LYS)))
234     #define IS_CYCLIC(x) ((x) & ((AA_HIS)|(AA_PHE)|(AA_PRO)|(AA_TRP)| \
235     (AA_TYR)))
236     #define IS_HYDROPHOBIC(x) ((x) & ((AA_ALA)|(AA_LEU)|(AA_VAL)|(AA_ILE)| \
237     (AA_PRO)|(AA_PHE)|(AA_MET)|(AA_TRP)))
238     #define IS_LARGE(x) ((x) & ((AA_ARG)|(AA_PHE)|(AA_GLN)|(AA_TYR)| \
239     (AA_HIS)|(AA_LEU)|(AA_LYS)|(AA_ILE)| \
240     (AA_GLU)|(AA_MET)|(AA_TRP)))
241     #define IS_MEDIUM(x) ((x) & ((AA_VAL)|(AA_THR)|(AA_ASP)|(AA_ASN)| \
242     (AA_PRO)|(AA_CYS)))
243     #define IS_NEGATIVE(x) ((x) & ((AA_ASP)|(AA_GLU)))
244     #define IS_NEUTRAL(x) ((x) & ((AA_ALA)|(AA_GLY)|(AA_LEU)|(AA_SER)| \
245     (AA_VAL)|(AA_THR)|(AA_PHE)|(AA_GLN)| \
246     (AA_TYR)|(AA_HIS)|(AA_CYS)|(AA_MET)| \
247     (AA_TRP)|(AA_ILE)|(AA_ASN)|(AA_PRO)))
248     #define IS_POLAR(x) ((x) & ((AA_ASP)|(AA_ILE)|(AA_ASN)|(AA_GLU)| \
249     (AA_SER)|(AA_THR)|(AA_ARG)|(AA_GLN)| \
250     (AA_CYS)|(AA_HIS)))
251     #define IS_POSITIVE(x) ((x) & ((AA_ARG)|(AA_HIS)|(AA_LYS)))
252     #define IS_SMALL(x) ((x) & ((AA_ALA)|(AA_GLY)|(AA_SER)))
253     #define IS_SURFACE(x) ((x) & ((AA_THR)|(AA_LYS)|(AA_ASP)|(AA_ILE)| \
254     (AA_ASN)|(AA_GLU)|(AA_PRO)|(AA_ARG)| \
255     (AA_GLY)|(AA_SER)|(AA_GLN)|(AA_TYR)| \
256     (AA_HIS)))
257    
258     ////////////////////////////////////////////////////////////////////////////////
259     // Global Variables
260     ////////////////////////////////////////////////////////////////////////////////
261    
262     static char Residue[MAXRES][4] = {
263     /*===============*/
264     /* Amino Acids */
265     /*===============*/
266    
267     /* Ordered by Cumulative Frequency in Brookhaven *
268     * Protein Databank, December 1991 */
269    
270     "ALA", /* 8.4% */ "GLY", /* 8.3% */
271     "LEU", /* 8.0% */ "SER", /* 7.5% */
272     "VAL", /* 7.1% */ "THR", /* 6.4% */
273     "LYS", /* 5.8% */ "ASP", /* 5.5% */
274     "ILE", /* 5.2% */ "ASN", /* 4.9% */
275     "GLU", /* 4.9% */ "PRO", /* 4.4% */
276     "ARG", /* 3.8% */ "PHE", /* 3.7% */
277     "GLN", /* 3.5% */ "TYR", /* 3.5% */
278     "HIS", /* 2.3% */ "CYS", /* 2.0% */
279     "MET", /* 1.8% */ "TRP", /* 1.4% */
280    
281     "ASX", "GLX", "PCA", "HYP",
282    
283     /*===================*/
284     /* DNA Nucleotides */
285     /*===================*/
286     " A", " C", " G", " T",
287    
288     /*===================*/
289     /* RNA Nucleotides */
290     /*===================*/
291     " U", " +U", " I", "1MA",
292     "5MC", "OMC", "1MG", "2MG",
293     "M2G", "7MG", "OMG", " YG",
294     "H2U", "5MU", "PSU",
295    
296     /*=================*/
297     /* Miscellaneous */
298     /*=================*/
299     "UNK", "ACE", "FOR", "HOH",
300     "DOD", "SO4", "PO4", "NAD",
301     "COA", "NAP", "NDP"
302     };
303    
304     /* Avoid SGI Compiler Warnings! */
305     static char ElemDesc[MAXELEM][4] = {
306     { ' ', 'N', ' ', ' ' }, /* 0*/
307     { ' ', 'C', 'A', ' ' }, /* 1*/
308     { ' ', 'C', ' ', ' ' }, /* 2*/
309     { ' ', 'O', ' ', ' ' }, /* 3*/ /* 0-3 Amino Acid Backbone */
310     { ' ', 'C', '\'', ' ' }, /* 4*/
311     { ' ', 'O', 'T', ' ' }, /* 5*/
312     { ' ', 'S', ' ', ' ' }, /* 6*/
313     { ' ', 'P', ' ', ' ' }, /* 7*/ /* 4-7 Shapely Amino Backbone */
314     { ' ', 'O', '1', 'P' }, /* 8*/
315     { ' ', 'O', '2', 'P' }, /* 9*/
316     { ' ', 'O', '5', '*' }, /*10*/
317     { ' ', 'C', '5', '*' }, /*11*/
318     { ' ', 'C', '4', '*' }, /*12*/
319     { ' ', 'O', '4', '*' }, /*13*/
320     { ' ', 'C', '3', '*' }, /*14*/
321     { ' ', 'O', '3', '*' }, /*15*/
322     { ' ', 'C', '2', '*' }, /*16*/
323     { ' ', 'O', '2', '*' }, /*17*/
324     { ' ', 'C', '1', '*' }, /*18*/ /* 7-18 Nucleic Acid Backbone */
325     { ' ', 'C', 'A', '2' }, /*19*/ /* 19 Shapely Special */
326     { ' ', 'S', 'G', ' ' }, /*20*/ /* 20 Cysteine Sulphur */
327     { ' ', 'N', '1', ' ' }, /*21*/
328     { ' ', 'N', '2', ' ' }, /*22*/
329     { ' ', 'N', '3', ' ' }, /*23*/
330     { ' ', 'N', '4', ' ' }, /*24*/
331     { ' ', 'N', '6', ' ' }, /*25*/
332     { ' ', 'O', '2', ' ' }, /*26*/
333     { ' ', 'O', '4', ' ' }, /*27*/
334     { ' ', 'O', '6', ' ' } /*28*/ /* 21-28 Nucleic Acid H-Bonding */
335     };
336    
337     static unsigned int ResNo = MINRES;
338     static unsigned int ElemNo = MINELEM;
339    
340     ///////////////////////////////////////////////////////////////////////////////
341     // Residue Functions
342     ///////////////////////////////////////////////////////////////////////////////
343    
344     static unsigned int GetAtomIDNumber(const char *atomid)
345     {
346     if (atomid != NULL)
347     {
348     int ch1 = toupper(atomid[0]);
349     int ch2 = toupper(atomid[1]);
350     int ch3 = toupper(atomid[2]);
351     int ch4 = toupper(atomid[3]);
352    
353     if (ch1 == ' ')
354     {
355     switch(ch2)
356     {
357     case 'C':
358    
359     switch(ch3)
360     {
361     case 'A':
362    
363     if (ch4 == ' ')
364     return 1;
365     else if (ch4 == '2')
366     return 19;
367    
368     break;
369    
370     case ' ':
371     if (ch4 == ' ')
372     return 2;
373     break;
374    
375     case '\'':
376     if (ch4 == ' ')
377     return 4;
378     break;
379    
380     case '1':
381     if (ch4 == '*')
382     return 18;
383     break;
384    
385     case '2':
386     if (ch4 == '*')
387     return 16;
388     break;
389    
390     case '3':
391     if (ch4 == '*')
392     return 14;
393     break;
394    
395     case '4':
396     if (ch4 == '*')
397     return 12;
398     break;
399    
400     case '5':
401     if (ch4 == '*')
402     return 11;
403     break;
404    
405     }
406    
407     break;
408    
409     case 'N':
410    
411     if (ch4 == ' ')
412     {
413     switch (ch3)
414     {
415     case ' ':
416     return 0;
417     case '1':
418     return 21;
419     case '2':
420     return 22;
421     case '3':
422     return 23;
423     case '4':
424     return 24;
425     case '6':
426     return 25;
427     }
428     }
429    
430     break;
431    
432     case 'O':
433    
434     switch(ch3)
435     {
436     case ' ':
437    
438     if (ch4 == ' ')
439     return 3;
440    
441     break;
442    
443     case 'T':
444    
445     if (ch4 == ' ')
446     return 5;
447    
448     break;
449    
450     case '1':
451    
452     if (ch4 == 'P')
453     return 8;
454    
455     break;
456    
457     case '2':
458    
459     if (ch4 == 'P')
460     return 9;
461     else if (ch4 == '*')
462     return 17;
463     else if (ch4 == ' ')
464     return 26;
465    
466     break;
467    
468     case '3':
469    
470     if (ch4 == '*')
471     return 15;
472    
473     break;
474    
475     case '4':
476    
477     if (ch4 == '*')
478     return 13;
479     else if (ch4 == ' ')
480     return 27;
481    
482     break;
483    
484     case '5':
485    
486     if (ch4 == '*')
487     return 10;
488    
489     break;
490    
491     case '6':
492    
493     if (ch4 == ' ')
494     return 28;
495    
496     break;
497     }
498    
499     break;
500    
501     case 'P':
502    
503     if ((ch3 == ' ') && (ch4 == ' '))
504     return 7;
505    
506     break;
507    
508     case 'S':
509    
510     if (ch4 == ' ')
511     {
512     if (ch3 == ' ')
513     return 6;
514     else if (ch3 == 'G')
515     return 20;
516     }
517    
518     break;
519     }
520     }
521    
522     unsigned int refno;
523     for( refno = MINELEM ; refno < ElemNo ; refno++ )
524     if( !strncmp(ElemDesc[refno], atomid, 4) )
525     return refno;
526    
527     if ( ElemNo < MAXELEM - 1 )
528     {
529     ElemNo++;
530     ElemDesc[refno][0] = (char) ch1;
531     ElemDesc[refno][1] = (char) ch2;
532     ElemDesc[refno][2] = (char) ch3;
533     ElemDesc[refno][3] = (char) ch4;
534     return refno;
535     }
536     else
537     {
538     obErrorLog.ThrowError(__FUNCTION__, "Maximum number of atom ids exceeded", obWarning);
539     return 0;
540     }
541     }
542     else
543     {
544     obErrorLog.ThrowError(__FUNCTION__, "NULL Atom IDs specified", obWarning);
545     return 0;
546     }
547     }
548    
549     static unsigned int GetResidueNumber(const char *res)
550     {
551     if (res != NULL)
552     {
553     int ch1 = toupper(res[0]);
554     int ch2 = toupper(res[1]);
555     int ch3 = toupper(res[2]);
556    
557     switch( ch1 )
558     {
559     case(' '):
560    
561     if( ch2 == ' ' )
562     {
563     switch( ch3 )
564     {
565     case('A'): return( 24 );
566     case('C'): return( 25 );
567     case('G'): return( 26 );
568     case('T'): return( 27 );
569     case('U'): return( 28 );
570     case('I'): return( 30 );
571     }
572     }
573     else if( ch2 == '+' )
574     {
575     if( ch3 == 'U' )
576     return( 29 );
577     }
578     else if( ch2 == 'Y' )
579     {
580     if( ch3 == 'G' )
581     return( 39 );
582     }
583    
584     break;
585    
586     case('0'):
587    
588     if( ch2 == 'M' )
589     {
590     if( ch3 == 'C' )
591     return( 33 );
592     else if( ch3 == 'G' )
593     return( 38 );
594     }
595    
596     break;
597    
598     case('1'):
599    
600     if( ch2 == 'M' )
601     {
602     if( ch3 == 'A' )
603     return( 31 );
604     else if( ch3 == 'G' )
605     return( 34 );
606     }
607    
608     break;
609    
610     case('2'):
611    
612     if( ch2 == 'M' )
613     if( ch3 == 'G' )
614     return( 35 );
615    
616     break;
617    
618     case('5'):
619    
620     if( ch2 == 'M' )
621     {
622     if( ch3 == 'C' )
623     return( 32 );
624     else if( ch3 == 'U' )
625     return( 41 );
626     }
627    
628     break;
629    
630     case('7'):
631    
632     if( ch2 == 'M' )
633     if( ch3 == 'G' )
634     return( 37 );
635    
636     break;
637    
638     case('A'):
639    
640     if( ch2 == 'L' )
641     {
642     if( ch3 == 'A' )
643     return( 0 );
644     }
645     else if( ch2 == 'S' )
646     {
647     if( ch3 == 'P' )
648     return( 7 );
649     else if( ch3 == 'N' )
650     return( 9 );
651     else if( ch3 == 'X' )
652     return( 20 );
653     }
654     else if( ch2 == 'R' )
655     {
656     if( ch3 == 'G' )
657     return( 12 );
658     }
659     else if( ch2 == 'C' )
660     {
661     if( ch3 == 'E' )
662     return( 44 );
663     }
664     else if( ch2 == 'D' )
665     {
666     if( ch3 == 'E' )
667     return( 24 ); /* "ADE" -> " A" */
668     }
669    
670     break;
671    
672     case('C'):
673    
674     if( ch2 == 'Y' )
675     {
676     if( ch3 == 'S' )
677     return( 17 );
678     else if( ch3 == 'H' )
679     return( 17 ); /* "CYH" -> "CYS" */
680     else if( ch3 == 'T' )
681     return( 25 ); /* "CYT" -> " C" */
682     }
683     else if( ch2 == 'O' )
684     {
685     if( ch3 == 'A' )
686     return( 51 );
687     }
688     else if( ch2 == 'P' )
689     {
690     if( ch3 == 'R' )
691     return( 11 ); /* "CPR" -> "PRO" */
692     }
693     else if( ch2 == 'S' )
694     {
695     if( ch3 == 'H' )
696     return( 17 ); /* "CSH" -> "CYS" */
697     else if( ch3 == 'M' )
698     return( 17 ); /* "CSM" -> "CYS" */
699     }
700    
701     break;
702    
703     case('D'):
704    
705     if( ch2 == 'O' )
706     {
707     if( ch3 == 'D' )
708     return( 47 );
709     }
710     else if( ch2 == '2' )
711     {
712     if( ch3 == 'O' )
713     return( 47 ); /* "D2O" -> "DOD" */
714     }
715    
716     break;
717    
718     case('F'):
719    
720     if( ch2 == 'O' )
721     if( ch3 == 'R' )
722     return( 45 );
723    
724     break;
725    
726     case('G'):
727    
728     if( ch2 == 'L' )
729     {
730     if( ch3 == 'Y' )
731     return( 1 );
732     else if( ch3 == 'U' )
733     return( 10 );
734     else if( ch3 == 'N' )
735     return( 14 );
736     else if( ch3 == 'X' )
737     return( 21 );
738     }
739     else if( ch2 == 'U' )
740     {
741     if( ch3 == 'A' )
742     return( 26 ); /* "GUA" -> " G" */
743     }
744    
745     break;
746    
747     case('H'):
748    
749     if( ch2 == 'I' )
750     {
751     if( ch3 == 'S' )
752     return( 16 );
753     }
754     else if( ch2 == 'O' )
755     {
756     if( ch3 == 'H' )
757     return( 46 );
758     }
759     else if( ch2 == 'Y' )
760     {
761     if( ch3 == 'P' )
762     return( 23 );
763     }
764     else if( ch2 == '2' )
765     {
766     if( ch3 == 'O' )
767     return( 46 ); /* "H20" -> "HOH" */
768     else if( ch3 == 'U' )
769     return( 40 );
770     }
771    
772     break;
773    
774     case('I'):
775    
776     if( ch2 == 'L' )
777     if( ch3 == 'E' )
778     return( 8 );
779    
780     break;
781    
782     case('L'):
783    
784     if( ch2 == 'E' )
785     {
786     if( ch3 == 'U' )
787     return( 2 );
788     }
789     else if( ch2 == 'Y' )
790     {
791     if( ch3 == 'S' )
792     return( 6 );
793     }
794    
795     break;
796    
797     case('M'):
798    
799     if( ch2 == 'E' )
800     {
801     if( ch3 == 'T' )
802     return( 18 );
803     }
804     else if( ch2 == '2' )
805     {
806     if( ch3 == 'G' )
807     return( 36 );
808     }
809    
810     break;
811    
812     case('N'):
813    
814     if( ch2 == 'A' )
815     {
816     if( ch3 == 'D' )
817     return( 50 );
818     else if( ch3 == 'P' )
819     return( 52 );
820     }
821     else if( ch2 == 'D' )
822     {
823     if( ch3 == 'P' )
824     return( 53 );
825     }
826    
827     break;
828    
829     case('P'):
830    
831     if( ch2 == 'R' )
832     {
833     if( ch3 == 'O' )
834     return( 11 );
835     }
836     else if( ch2 == 'H' )
837     {
838     if( ch3 == 'E' )
839     return( 13 );
840     }
841     else if( ch2 == 'C' )
842     {
843     if( ch3 == 'A' )
844     return( 22 );
845     }
846     else if( ch2 == 'O' )
847     {
848     if( ch3 == '4' )
849     return( 49 );
850     }
851     else if( ch2 == 'S' )
852     {
853     if( ch3 == 'U' )
854     return( 42 );
855     }
856    
857     break;
858    
859     case('S'):
860    
861     if( ch2 == 'E' )
862     {
863     if( ch3 == 'R' )
864     return( 3 );
865     }
866     else if( ch2 == 'O' )
867     {
868     if( ch3 == '4' )
869     return( 48 );
870     else if( ch3 == 'L' )
871     return( 46 ); /* "SOL" -> "HOH" */
872     }
873     else if( ch2 == 'U' )
874     {
875     if( ch3 == 'L' )
876     return( 48 ); /* "SUL" -> "SO4" */
877     }
878    
879     break;
880    
881     case('T'):
882    
883     if( ch2 == 'H' )
884     {
885     if( ch3 == 'R' )
886     return( 5 );
887     else if( ch3 == 'Y' )
888     return( 27 ); /* "THY" -> " T" */
889     }
890     else if( ch2 == 'Y' )
891     {
892     if( ch3 == 'R' )
893     return( 15 );
894     }
895     else if( ch2 == 'R' )
896     {
897     if( ch3 == 'P' )
898     return( 19 );
899     else if( ch3 == 'Y' )
900     return( 19 ); /* "TRY" -> "TRP" */
901     }
902     else if( ch2 == 'I' )
903     {
904     if( ch3 == 'P' )
905     return( 46 ); /* "TIP" -> "HOH" */
906     }
907    
908     break;
909    
910     case('U'):
911    
912     if( ch2 == 'N' )
913     {
914     if( ch3 == 'K' )
915     return( 43 );
916     }
917     else if( ch2 == 'R' )
918     {
919     if( ch3 == 'A' )
920     return( 28 ); /* "URA" -> " U" */
921     else if( ch3 == 'I' )
922     return( 28 ); /* "URI" -> " U" */
923     }
924    
925     break;
926    
927     case('V'):
928    
929     if( ch2 == 'A' )
930     if( ch3 == 'L' )
931     return( 4 );
932    
933     break;
934    
935     case('W'):
936    
937     if( ch2 == 'A' )
938     if( ch3 == 'T' )
939     return( 46 ); /* "WAT" -> "HOH" */
940    
941     break;
942     }
943    
944     unsigned int refno;
945     for( refno = MINRES; refno < ResNo ; refno++ )
946     if( !strncmp(Residue[refno],res,3) )
947     return refno;
948    
949     if ( ResNo < MAXRES - 1 )
950     {
951     ResNo++;
952     Residue[refno][0] = (char) ch1;
953     Residue[refno][1] = (char) ch2;
954     Residue[refno][2] = (char) ch3;
955     return refno;
956     }
957     }
958    
959     return OBResidueIndex::UNK;
960     }
961    
962     static void SetResidueKeys(const char *residue,
963     unsigned int &reskey,
964     unsigned int &aakey)
965     {
966     reskey = GetResidueNumber(residue);
967     switch(reskey)
968     {
969     case OBResidueIndex::ALA:
970     aakey = AA_ALA;
971     break;
972     case OBResidueIndex::GLY:
973     aakey = AA_GLY;
974     break;
975     case OBResidueIndex::LEU:
976     aakey = AA_LEU;
977     break;
978     case OBResidueIndex::SER:
979     aakey = AA_SER;
980     break;
981     case OBResidueIndex::VAL:
982     aakey = AA_VAL;
983     break;
984     case OBResidueIndex::THR:
985     aakey = AA_THR;
986     break;
987     case OBResidueIndex::LYS:
988     aakey = AA_LYS;
989     break;
990     case OBResidueIndex::ASP:
991     aakey = AA_ASP;
992     break;
993     case OBResidueIndex::ILE:
994     aakey = AA_ILE;
995     break;
996     case OBResidueIndex::ASN:
997     aakey = AA_ASN;
998     break;
999     case OBResidueIndex::GLU:
1000     aakey = AA_GLU;
1001     break;
1002     case OBResidueIndex::PRO:
1003     aakey = AA_PRO;
1004     break;
1005     case OBResidueIndex::ARG:
1006     aakey = AA_ARG;
1007     break;
1008     case OBResidueIndex::PHE:
1009     aakey = AA_PHE;
1010     break;
1011     case OBResidueIndex::GLN:
1012     aakey = AA_GLN;
1013     break;
1014     case OBResidueIndex::TYR:
1015     aakey = AA_TYR;
1016     break;
1017     case OBResidueIndex::HIS:
1018     aakey = AA_HIS;
1019     break;
1020     case OBResidueIndex::CYS:
1021     aakey = AA_CYS;
1022     break;
1023     case OBResidueIndex::MET:
1024     aakey = AA_MET;
1025     break;
1026     case OBResidueIndex::TRP:
1027     aakey = AA_TRP;
1028     break;
1029     default:
1030     aakey = 0;
1031     break;
1032     }
1033     }
1034    
1035     ///////////////////////////////////////////////////////////////////////////////
1036     // OBResidue: Constructors / Destructor
1037     ///////////////////////////////////////////////////////////////////////////////
1038    
1039     OBResidue::OBResidue()
1040     {
1041     _chain = 'A';
1042     _idx = 0;
1043     _aakey = 0;
1044     _reskey = OBResidueIndex::UNK;
1045     _resnum = 0;
1046     _resname = "";
1047     _vdata.clear();
1048     }
1049    
1050     OBResidue::OBResidue(const OBResidue &src)
1051     // Currently does not copy vdata information
1052     {
1053     _chain = src._chain;
1054     _aakey = src._aakey;
1055     _reskey = src._reskey;
1056     _resnum = src._resnum;
1057     _resname = src._resname;
1058     _atomid = src._atomid;
1059     _hetatm = src._hetatm;
1060     _sernum = src._sernum;
1061     }
1062    
1063     OBResidue::~OBResidue()
1064     {
1065     vector<OBAtom*>::iterator a;
1066     for ( a = _atoms.begin() ; a != _atoms.end() ; a++ )
1067     (*a)->SetResidue(NULL);
1068     _atoms.clear();
1069     if (!_vdata.empty())
1070     {
1071     vector<OBGenericData*>::iterator m;
1072     for (m = _vdata.begin();m != _vdata.end();m++)
1073     delete *m;
1074     _vdata.clear();
1075     }
1076     }
1077    
1078     ///////////////////////////////////////////////////////////////////////////////
1079     // OBResidue: Operator Overloads
1080     ///////////////////////////////////////////////////////////////////////////////
1081    
1082     OBResidue &OBResidue::operator = (const OBResidue &src)
1083     //copy residue information
1084     // Currently does not copy vdata informtion
1085     {
1086     if (this != &src)
1087     {
1088     _chain = src._chain;
1089     _aakey = src._aakey;
1090     _reskey = src._reskey;
1091     _resnum = src._resnum;
1092     _resname = src._resname;
1093     _atomid = src._atomid;
1094     _hetatm = src._hetatm;
1095     _sernum = src._sernum;
1096     }
1097    
1098     return(*this);
1099     }
1100    
1101     ///////////////////////////////////////////////////////////////////////////////
1102     // OBResidue: Data Access / Manipulation
1103     ///////////////////////////////////////////////////////////////////////////////
1104    
1105     void OBResidue::AddAtom(OBAtom *atom)
1106     {
1107     if (atom != NULL)
1108     {
1109     atom->SetResidue(this);
1110    
1111     _atoms.push_back(atom);
1112     _atomid.push_back("");
1113     _hetatm.push_back(false);
1114     _sernum.push_back(0);
1115     }
1116     }
1117    
1118     void OBResidue::InsertAtom(OBAtom *atom)
1119     {
1120     if (atom != NULL)
1121     {
1122     atom->SetResidue(this);
1123    
1124     _atoms.push_back(atom);
1125     _atomid.push_back("");
1126     _hetatm.push_back(false);
1127     _sernum.push_back(0);
1128     }
1129     }
1130    
1131     void OBResidue::RemoveAtom(OBAtom *atom)
1132     {
1133     if (atom != NULL)
1134     {
1135     for ( unsigned int i = 0 ; i < _atoms.size() ; i++ )
1136     {
1137     if (_atoms[i] == atom)
1138     {
1139     atom->SetResidue(NULL);
1140     _atoms.erase(_atoms.begin() + i);
1141     _atomid.erase(_atomid.begin() + i);
1142     _hetatm.erase(_hetatm.begin() + i);
1143     _sernum.erase(_sernum.begin() + i);
1144     }
1145     }
1146     }
1147     }
1148    
1149     void OBResidue::Clear(void)
1150     {
1151     for (unsigned int i = 0 ; i < _atoms.size() ; i++ )
1152     _atoms[i]->SetResidue(NULL);
1153    
1154     _chain = 'A';
1155     _idx = 0;
1156     _aakey = 0;
1157     _reskey = OBResidueIndex::UNK;
1158     _resnum = 0;
1159     _resname = "";
1160    
1161     _atoms.clear();
1162     _atomid.clear();
1163     _hetatm.clear();
1164     _sernum.clear();
1165     }
1166    
1167     void OBResidue::SetChain(char chain)
1168     {
1169     _chain = chain;
1170     }
1171    
1172     void OBResidue::SetChainNum(unsigned int chainnum)
1173     {
1174     _chain = (char) ('A' + chainnum - 1);
1175     }
1176    
1177     void OBResidue::SetIdx(unsigned int idx)
1178     {
1179     _idx = idx;
1180     }
1181    
1182     void OBResidue::SetName(const string &name)
1183     {
1184     _resname = name;
1185     SetResidueKeys(_resname.c_str(), _reskey, _aakey);
1186     }
1187    
1188     void OBResidue::SetNum(unsigned int resnum)
1189     {
1190     _resnum = resnum;
1191     }
1192    
1193     void OBResidue::SetAtomID(OBAtom *atom, const string &id)
1194     {
1195     for ( unsigned int i = 0 ; i < _atoms.size() ; i++ )
1196     if (_atoms[i] == atom)
1197     _atomid[i] = id;
1198     }
1199    
1200     void OBResidue::SetHetAtom(OBAtom *atom, bool hetatm)
1201     {
1202     for ( unsigned int i = 0 ; i < _atoms.size() ; i++ )
1203     if (_atoms[i] == atom)
1204     _hetatm[i] = hetatm;
1205     }
1206    
1207     void OBResidue::SetSerialNum(OBAtom *atom, unsigned int sernum)
1208     {
1209     for ( unsigned int i = 0 ; i < _atoms.size() ; i++ )
1210     if (_atoms[i] == atom)
1211     _sernum[i] = sernum;
1212     }
1213    
1214     vector<OBAtom*> OBResidue::GetAtoms(void) const
1215     {
1216     return _atoms;
1217     }
1218    
1219     vector<OBBond*> OBResidue::GetBonds(bool exterior) const
1220     {
1221     OBAtom *atom;
1222     vector<OBBond*> bonds;
1223     OBBitVec idxs;
1224     unsigned int sz;
1225    
1226     sz = (unsigned int) _atoms.size();
1227     for ( unsigned int i = 0 ; i < sz ; i++ )
1228     {
1229     atom = _atoms[i];
1230     OBBond *bond;
1231     vector<OBEdgeBase*>::iterator b;
1232     for (bond = atom->BeginBond(b) ; bond ; bond = atom->NextBond(b))
1233     {
1234     if (!idxs.BitIsOn(bond->GetIdx()))
1235     {
1236     if (!exterior)
1237     {
1238     if (bond->GetNbrAtom(atom)->GetResidue() == this)
1239     bonds.push_back(&(*bond));
1240     }
1241     else
1242     bonds.push_back(&(*bond));
1243    
1244     idxs.SetBitOn(bond->GetIdx());
1245     }
1246     }
1247     }
1248    
1249     return bonds;
1250     }
1251    
1252     string OBResidue::GetName(void) const
1253     {
1254     return _resname;
1255     }
1256    
1257     unsigned int OBResidue::GetNum(void) const
1258     {
1259     return _resnum;
1260     }
1261    
1262     unsigned int OBResidue::GetNumAtoms(void) const
1263     {
1264     return (unsigned int)_atoms.size();
1265     }
1266    
1267     char OBResidue::GetChain(void) const
1268     {
1269     return _chain;
1270     }
1271    
1272     unsigned int OBResidue::GetChainNum(void) const
1273     {
1274     if (isdigit(_chain))
1275     return (_chain - '0');
1276     else
1277     return (_chain - 'A' + 1);
1278     }
1279    
1280     unsigned int OBResidue::GetIdx(void) const
1281     {
1282     return(_idx);
1283     }
1284    
1285     unsigned int OBResidue::GetResKey(void) const
1286     {
1287     return(_reskey);
1288     }
1289    
1290     string OBResidue::GetAtomID(OBAtom *atom) const
1291     {
1292     for ( unsigned int i = 0 ; i < _atoms.size() ; i++ )
1293     if (_atoms[i] == atom)
1294     return _atomid[i];
1295     return "";
1296     }
1297    
1298     unsigned int OBResidue::GetSerialNum(OBAtom *atom) const
1299     {
1300     for ( unsigned int i = 0 ; i < _atoms.size() ; i++ )
1301     if (_atoms[i] == atom)
1302     return _sernum[i];
1303     return 0;
1304     }
1305    
1306     bool OBResidue::IsHetAtom(OBAtom *atom) const
1307     {
1308     for ( unsigned int i = 0 ; i < _atoms.size() ; i++ )
1309     if (_atoms[i] == atom)
1310     return _hetatm[i];
1311     return false;
1312     }
1313    
1314     ///////////////////////////////////////////////////////////////////////////////
1315     // OBResidue: Iteration Utilities
1316     ///////////////////////////////////////////////////////////////////////////////
1317    
1318     OBAtom *OBResidue::BeginAtom(vector<OBAtom*>::iterator &i)
1319     {
1320     i = _atoms.begin();
1321     return ((i == _atoms.end()) ? NULL : *i);
1322     }
1323    
1324     OBAtom *OBResidue::NextAtom(vector<OBAtom*>::iterator &i)
1325     {
1326     i++;
1327     return ((i == _atoms.end()) ? NULL : *i);
1328     }
1329    
1330     ///////////////////////////////////////////////////////////////////////////////
1331     // OBResidue: Information Functions
1332     ///////////////////////////////////////////////////////////////////////////////
1333    
1334     bool OBResidue::GetAminoAcidProperty(int property) const
1335     {
1336     switch(property)
1337     {
1338     case OBAminoAcidProperty::ACIDIC:
1339     return IS_ACIDIC(_aakey) != 0;
1340     case OBAminoAcidProperty::ACYCLIC:
1341     return IS_ACYCLIC(_aakey) != 0;
1342     case OBAminoAcidProperty::ALIPHATIC:
1343     return IS_ALIPHATIC(_aakey) != 0;
1344     case OBAminoAcidProperty::AROMATIC:
1345     return IS_AROMATIC(_aakey) != 0;
1346     case OBAminoAcidProperty::BASIC:
1347     return IS_BASIC(_aakey) != 0;
1348     case OBAminoAcidProperty::BURIED:
1349     return IS_BURIED(_aakey) != 0;
1350     case OBAminoAcidProperty::CHARGED:
1351     return IS_CHARGED(_aakey) != 0;
1352     case OBAminoAcidProperty::CYCLIC:
1353     return IS_CYCLIC(_aakey) != 0;
1354     case OBAminoAcidProperty::HYDROPHOBIC:
1355     return IS_HYDROPHOBIC(_aakey) != 0;
1356     case OBAminoAcidProperty::LARGE:
1357     return IS_LARGE(_aakey) != 0;
1358     case OBAminoAcidProperty::MEDIUM:
1359     return IS_MEDIUM(_aakey) != 0;
1360     case OBAminoAcidProperty::NEGATIVE:
1361     return IS_NEGATIVE(_aakey) != 0;
1362     case OBAminoAcidProperty::NEUTRAL:
1363     return IS_NEUTRAL(_aakey) != 0;
1364     case OBAminoAcidProperty::POLAR:
1365     return IS_POLAR(_aakey) != 0;
1366     case OBAminoAcidProperty::POSITIVE:
1367     return IS_POSITIVE(_aakey) != 0;
1368     case OBAminoAcidProperty::SMALL:
1369     return IS_SMALL(_aakey) != 0;
1370     case OBAminoAcidProperty::SURFACE:
1371     return IS_SURFACE(_aakey) != 0;
1372     default:
1373     return false;
1374     }
1375     }
1376    
1377     bool OBResidue::GetAtomProperty(OBAtom *atom, int property) const
1378     {
1379     if (atom != NULL)
1380     {
1381     unsigned int atomid = GetAtomIDNumber(GetAtomID(atom).c_str());
1382    
1383     switch(property)
1384     {
1385     case OBResidueAtomProperty::ALPHA_CARBON:
1386     return (atomid == 1);
1387    
1388     case OBResidueAtomProperty::AMINO_BACKBONE:
1389     return (atomid <= 3);
1390    
1391     case OBResidueAtomProperty::BACKBONE:
1392     return (atomid <= 18);
1393    
1394     case OBResidueAtomProperty::CYSTEINE_SULPHUR:
1395     return (atomid == 20);
1396    
1397     case OBResidueAtomProperty::LIGAND:
1398     return IsHetAtom(atom) &&
1399     !GetResidueProperty(OBResidueProperty::SOLVENT);
1400    
1401     case OBResidueAtomProperty::NUCLEIC_BACKBONE:
1402     return ((atomid >= 7) && (atomid <= 18));
1403    
1404     case OBResidueAtomProperty::SHAPELY_BACKBONE:
1405     return (atomid <= 7);
1406    
1407     case OBResidueAtomProperty::SHAPELY_SPECIAL:
1408     return (atomid == 19);
1409    
1410     case OBResidueAtomProperty::SIDECHAIN:
1411     return GetResidueProperty(OBResidueProperty::AMINO_NUCLEO) &&
1412     (atomid > 18);
1413    
1414     case OBResidueAtomProperty::SUGAR_PHOSPHATE:
1415     return (atomid == 7);
1416     }
1417     }
1418    
1419     return false;
1420     }
1421    
1422     bool OBResidue::GetResidueProperty(int property) const
1423     {
1424     switch(property)
1425     {
1426     case OBResidueProperty::AMINO:
1427     return (_reskey <= OBResidueIndex::HYP);
1428    
1429     case OBResidueProperty::AMINO_NUCLEO:
1430     return (_reskey <= OBResidueIndex::PSU);
1431    
1432     case OBResidueProperty::COENZYME:
1433     return (_reskey >= OBResidueIndex::NAD) &&
1434     (_reskey <= OBResidueIndex::NDP);
1435    
1436     case OBResidueProperty::ION:
1437     return (_reskey == OBResidueIndex::SO4) ||
1438     (_reskey == OBResidueIndex::PO4);
1439    
1440     case OBResidueProperty::NUCLEO:
1441     return (_reskey >= OBResidueIndex::A) &&
1442     (_reskey <= OBResidueIndex::PSU);
1443    
1444     case OBResidueProperty::PROTEIN:
1445     return (_reskey <= OBResidueIndex::HYP) ||
1446     ((_reskey >= OBResidueIndex::UNK) &&
1447     (_reskey <= OBResidueIndex::FOR));
1448    
1449     case OBResidueProperty::PURINE:
1450     return (_reskey == OBResidueIndex::A) ||
1451     (_reskey == OBResidueIndex::G);
1452    
1453     case OBResidueProperty::PYRIMIDINE:
1454     return (_reskey == OBResidueIndex::C) ||
1455     (_reskey == OBResidueIndex::T);
1456    
1457     case OBResidueProperty::SOLVENT:
1458     return (_reskey >= OBResidueIndex::HOH) &&
1459     (_reskey <= OBResidueIndex::PO4);
1460    
1461     case OBResidueProperty::WATER:
1462     return (_reskey == OBResidueIndex::HOH) ||
1463     (_reskey == OBResidueIndex::DOD);
1464    
1465     default:
1466     return false;
1467     }
1468     }
1469    
1470     bool OBResidue::IsResidueType(int restype) const
1471     {
1472     return ((int)_reskey == restype);
1473     }
1474    
1475     // OBGenericData methods
1476     bool OBResidue::HasData(string &s)
1477     //returns true if the generic attribute/value pair exists
1478     {
1479     if (_vdata.empty())
1480     return(false);
1481    
1482     vector<OBGenericData*>::iterator i;
1483    
1484     for (i = _vdata.begin();i != _vdata.end();i++)
1485     if ((*i)->GetAttribute() == s)
1486     return(true);
1487    
1488     return(false);
1489     }
1490    
1491     bool OBResidue::HasData(const char *s)
1492     //returns true if the generic attribute/value pair exists
1493     {
1494     if (_vdata.empty())
1495     return(false);
1496    
1497     vector<OBGenericData*>::iterator i;
1498    
1499     for (i = _vdata.begin();i != _vdata.end();i++)
1500     if ((*i)->GetAttribute() == s)
1501     return(true);
1502    
1503     return(false);
1504     }
1505    
1506     bool OBResidue::HasData(unsigned int dt)
1507     //returns true if the generic attribute/value pair exists
1508     {
1509     if (_vdata.empty())
1510     return(false);
1511    
1512     vector<OBGenericData*>::iterator i;
1513    
1514     for (i = _vdata.begin();i != _vdata.end();i++)
1515     if ((*i)->GetDataType() == dt)
1516     return(true);
1517    
1518     return(false);
1519     }
1520    
1521     OBGenericData *OBResidue::GetData(string &s)
1522     //returns the value given an attribute
1523     {
1524     vector<OBGenericData*>::iterator i;
1525    
1526     for (i = _vdata.begin();i != _vdata.end();i++)
1527     if ((*i)->GetAttribute() == s)
1528     return(*i);
1529    
1530     return(NULL);
1531     }
1532    
1533     OBGenericData *OBResidue::GetData(const char *s)
1534     //returns the value given an attribute
1535     {
1536     vector<OBGenericData*>::iterator i;
1537    
1538     for (i = _vdata.begin();i != _vdata.end();i++)
1539     if ((*i)->GetAttribute() == s)
1540     return(*i);
1541    
1542     return(NULL);
1543     }
1544    
1545     OBGenericData *OBResidue::GetData(unsigned int dt)
1546     {
1547     vector<OBGenericData*>::iterator i;
1548     for (i = _vdata.begin();i != _vdata.end();i++)
1549     if ((*i)->GetDataType() == dt)
1550     return(*i);
1551     return(NULL);
1552     }
1553    
1554     void OBResidue::DeleteData(unsigned int dt)
1555     {
1556     vector<OBGenericData*> vdata;
1557     vector<OBGenericData*>::iterator i;
1558     for (i = _vdata.begin();i != _vdata.end();i++)
1559     if ((*i)->GetDataType() == dt)
1560     delete *i;
1561     else
1562     vdata.push_back(*i);
1563     _vdata = vdata;
1564     }
1565    
1566     void OBResidue::DeleteData(vector<OBGenericData*> &vg)
1567     {
1568     vector<OBGenericData*> vdata;
1569     vector<OBGenericData*>::iterator i,j;
1570    
1571     bool del;
1572     for (i = _vdata.begin();i != _vdata.end();i++)
1573     {
1574     del = false;
1575     for (j = vg.begin();j != vg.end();j++)
1576     if (*i == *j)
1577     {
1578     del = true;
1579     break;
1580     }
1581     if (del)
1582     delete *i;
1583     else
1584     vdata.push_back(*i);
1585     }
1586     _vdata = vdata;
1587     }
1588    
1589     void OBResidue::DeleteData(OBGenericData *gd)
1590     {
1591     vector<OBGenericData*>::iterator i;
1592     for (i = _vdata.begin();i != _vdata.end();i++)
1593     if (*i == gd)
1594     {
1595     delete *i;
1596     _vdata.erase(i);
1597     }
1598    
1599     }
1600    
1601     } // end namespace OpenBabel
1602    
1603     //! \file residue.cpp
1604     //! \brief Handle macromolecule residues.