← Back to branch summary

~ubuntu-branches/ubuntu/breezy/ncbi-tools6/breezy

« back to all changes in this revision

Viewing changes to biostruc/newvast/mkbioseq_vs.c

  • Committer: Bazaar Package Importer
  • Author(s): Aaron M. Ucko
  • Date: 2004-06-26 00:18:09 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040626001809-ma39ub7j6dbh8r3t
Tags: 6.1.20040616-1
* New upstream release.
* debian/blast2.docs: adjusted for new arrangement (a separate
  source-tree directory full of HTML files).
* debian/{control,lib*-dbg.install,rules}: switch to new-style -dbg
  packages containing just the stripped-out symbols.
* debian/{installman,ncbi-tools-bin.install,rules}: upstream has dropped
  f(asta)merge.

Show diffs side-by-side

added added

removed removed

Lines of Context:
biostruc/newvast/mkbioseq_vs.c
 
1
/* mkbioseq_vs.c
 
2
 *
 
3
 * ===========================================================================
 
4
 *
 
5
 *                            PUBLIC DOMAIN NOTICE
 
6
 *            National Center for Biotechnology Information (NCBI)
 
7
 *
 
8
 *  This software/database is a "United States Government Work" under the
 
9
 *  terms of the United States Copyright Act.  It was written as part of
 
10
 *  the author's official duties as a United States Government employee and
 
11
 *  thus cannot be copyrighted.  This software/database is freely available
 
12
 *  to the public for use. The National Library of Medicine and the U.S.
 
13
 *  Government do not place any restriction on its use or reproduction.
 
14
 *  We would, however, appreciate having the NCBI and the author cited in
 
15
 *  any work or product based on this material
 
16
 *
 
17
 *  Although all reasonable efforts have been taken to ensure the accuracy
 
18
 *  and reliability of the software and data, the NLM and the U.S.
 
19
 *  Government do not and cannot warrant the performance or results that
 
20
 *  may be obtained by using this software or data. The NLM and the U.S.
 
21
 *  Government disclaim all warranties, express or implied, including
 
22
 *  warranties of performance, merchantability or fitness for any particular
 
23
 *  purpose.
 
24
 *
 
25
 * ===========================================================================
 
26
 *
 
27
 * File Name: mkbioseq_vs.c
 
28
 *
 
29
 * Author: Ken Addess
 
30
 *
 
31
 * $Log: mkbioseq_vs.c,v $
 
32
 * Revision 1.1.1.1  2002/12/06 20:17:21  chenj
 
33
 * Imported Scouces
 
34
 *
 
35
 * Revision 6.2  1999/06/15 18:12:53  addess
 
36
 * fixed some lines related to BioseqPtr
 
37
 *
 
38
 * Revision 6.2  1999/06/15 18:12:53  addess
 
39
 * fixed some lines related to BioseqPtr
 
40
 *
 
41
 * Revision 6.1  1998/07/17 18:59:57  madej
 
42
 * Created by Ken Addess.
 
43
 *
 
44
 */
 
45
 
 
46
/************************************************************/
 
47
/*                                                          */
 
48
/*      mkBioseqs()                                         */
 
49
/*                                                          */
 
50
/*      Creates a Bioseq/BioseqSet object from a Biostruc   */
 
51
/*      object and writes it out to a file.                 */
 
52
/*                                                          */
 
53
/************************************************************/ 
 
54
 
 
55
 
 
56
#include "mkbioseq.h"
 
57
 
 
58
static Int4 NumberOfBioChains(MoleculeGraphPtr mgp)
 
59
{
 
60
  ValNodePtr vnp;
 
61
  Int4 mtype, nbp = 0;
 
62
 
 
63
  while (mgp != NULL)
 
64
  {
 
65
      vnp = ValNodeFindNext(mgp->descr, NULL, BiomolDescr_molecule_type);
 
66
 
 
67
      if (vnp) mtype = vnp->data.intvalue;
 
68
 
 
69
     switch(mtype)
 
70
     {
 
71
         case 1:
 
72
         case 2:
 
73
         case 3:
 
74
            nbp++;
 
75
            break;
 
76
     }
 
77
        
 
78
      mgp = mgp->next;
 
79
  }
 
80
  
 
81
  return nbp;
 
82
} 
 
83
 
 
84
static MoleculeGraphPtr MakeBioGraphPtr(MoleculeGraphPtr mgp)
 
85
{
 
86
  MoleculeGraphPtr newbp, bp = NULL, currentbp;
 
87
  ValNodePtr vnp;
 
88
  Int4 mtype;
 
89
 
 
90
  while (mgp != NULL)
 
91
   {
 
92
      vnp = ValNodeFindNext(mgp->descr, NULL, BiomolDescr_molecule_type);
 
93
 
 
94
      if (vnp) mtype = vnp->data.intvalue;
 
95
 
 
96
      switch(mtype)
 
97
      {
 
98
         case 1:
 
99
         case 2:
 
100
         case 3:
 
101
            newbp = MoleculeGraphNew();
 
102
            newbp->id = mgp->id;
 
103
            newbp->descr = mgp->descr;
 
104
            newbp->seq_id = mgp->seq_id;
 
105
            newbp->residue_sequence = mgp->residue_sequence;
 
106
            newbp->inter_residue_bonds = mgp->inter_residue_bonds;
 
107
            if (bp == NULL)
 
108
            {
 
109
               bp = newbp;
 
110
            }
 
111
            else
 
112
            {
 
113
               currentbp->next = newbp;
 
114
            }
 
115
            currentbp = newbp;
 
116
            break;
 
117
      }
 
118
 
 
119
      mgp = mgp->next;
 
120
   }
 
121
   
 
122
  return bp;
 
123
}
 
124
 
 
125
static Int4 NumberOfHetChains(MoleculeGraphPtr mgp, MoleculeGraphPtr bp)
 
126
{
 
127
  ValNodePtr vnp;
 
128
  Int4 mtype, molecule_id, nhet = 0;
 
129
  CharPtr mname;
 
130
 
 
131
  while (mgp != NULL)
 
132
  {
 
133
    vnp = ValNodeFindNext(mgp->descr, NULL, BiomolDescr_molecule_type);
 
134
 
 
135
    if (vnp) mtype = vnp->data.intvalue;
 
136
 
 
137
    switch(mtype)
 
138
    {
 
139
      case 6:
 
140
      if (vnp = ValNodeFindNext(mgp->descr, NULL, BiomolDescr_name))
 
141
      mname = vnp->data.ptrvalue;
 
142
      molecule_id = atoi(mname);
 
143
            
 
144
      if (isBiopoly(molecule_id, bp))
 
145
      {
 
146
        nhet++;
 
147
      }
 
148
      break;
 
149
    }
 
150
   mgp = mgp->next;
 
151
  }
 
152
  return nhet;
 
153
}
 
154
 
 
155
static MoleculeGraphPtr MakeHetGraphPtr(MoleculeGraphPtr mgp, MoleculeGraphPtr bp)
 
156
{
 
157
  MoleculeGraphPtr newhet, het = NULL, currenthet;
 
158
  ValNodePtr vnp;
 
159
  Int4 mtype, molecule_id;
 
160
  CharPtr mname;
 
161
 
 
162
  while (mgp != NULL)
 
163
  {
 
164
      vnp = ValNodeFindNext(mgp->descr, NULL, BiomolDescr_molecule_type);
 
165
 
 
166
      if (vnp) mtype = vnp->data.intvalue;
 
167
 
 
168
      switch(mtype)
 
169
      {
 
170
        case 6:
 
171
          vnp = ValNodeFindNext(mgp->descr, NULL, BiomolDescr_name);
 
172
 
 
173
          if (vnp) mname = vnp->data.ptrvalue;
 
174
                  
 
175
          molecule_id = atoi(mname);
 
176
          if (isBiopoly(molecule_id, bp))
 
177
          {
 
178
            newhet = MoleculeGraphNew();
 
179
            newhet->id = mgp->id;
 
180
            newhet->descr = mgp->descr;
 
181
            newhet->seq_id = mgp->seq_id;
 
182
            newhet->residue_sequence = mgp->residue_sequence;
 
183
            newhet->inter_residue_bonds = mgp->inter_residue_bonds;
 
184
            if (het == NULL)
 
185
            {
 
186
              het = newhet;
 
187
            }
 
188
            else
 
189
            {
 
190
              currenthet->next = newhet;
 
191
            }
 
192
            currenthet = newhet;
 
193
          }
 
194
          break;
 
195
      }
 
196
 
 
197
   mgp = mgp->next;
 
198
  }
 
199
   
 
200
  return het;
 
201
}
 
202
 
 
203
 
 
204
SeqEntryPtr LIBCALL MakeBioseqs(BiostrucPtr bsp, BiostrucResidueGraphSetPtr stdDictionary)
 
205
{
 
206
  ValNodePtr vnp, seq_set, hetval, pvnThePoints;
 
207
  BiostrucHistoryPtr bhp;
 
208
  BiostrucSourcePtr bssp;
 
209
  BiostrucGraphPtr bsgp;
 
210
  BiostrucModelPtr bsmp;
 
211
  BiostrucFeatureSetPtr bsfsp;
 
212
  BiostrucFeaturePtr bsfp;
 
213
  ChemGraphPntrsPtr cgpp;
 
214
  ResiduePtr rs;
 
215
  ResidueGraphPtr rgp;
 
216
  ResiduePntrsPtr rpp;
 
217
  ResidueIntervalPntrPtr ripp;
 
218
  ResidueExplicitPntrsPtr rpp1=NULL, rpp2=NULL;
 
219
  MoleculeGraphPtr bp, het, currenthet, currentbp, mgp;
 
220
  InterResidueBondPtr currentabp, abp;
 
221
  DbtagPtr dtp;
 
222
  SeqEntryPtr pdb_entry;
 
223
  BioseqSetPtr biossp;
 
224
  BioseqPtr bioseqs[MAXNUM], current_bioseq;
 
225
  Int4 DomainNum, molId1, resId1, atmId1, molId2, resId2, atmId2;
 
226
  Int4 nbp, nhet, num_chain, index = 0, chnidx, bpchnidx, bpresidx, hetidx, rescount, bioseq_idx;
 
227
  Int4 ssresidx1, ssresidx2, ssmolidx1, ssmolidx2;
 
228
  CharPtr feature_name, rname;
 
229
  Boolean interchain, bonds, found1, found2;
 
230
  SeqAnnotPtr sap = NULL;
 
231
  SeqIdPtr sip;
 
232
 
 
233
  if (!bsp)
 
234
  {
 
235
    return NULL;
 
236
  }
 
237
      
 
238
  vnp = ValNodeFindNext(bsp->descr, NULL, BiostrucDescr_history);
 
239
 
 
240
  if (vnp)
 
241
  { 
 
242
    bhp = (BiostrucHistoryPtr) vnp->data.ptrvalue; 
 
243
    bssp = bhp->data_source;
 
244
  }
 
245
 
 
246
  bsgp = bsp->chemical_graph; 
 
247
  bsmp = bsp->model;
 
248
    
 
249
  nbp = NumberOfBioChains(bsgp->molecule_graphs);
 
250
   
 
251
  bp =  MakeBioGraphPtr(bsgp->molecule_graphs);
 
252
 
 
253
  nhet = NumberOfHetChains(bsgp->molecule_graphs, bp);
 
254
  
 
255
  het = MakeHetGraphPtr(bsgp->molecule_graphs, bp);
 
256
   
 
257
  pdb_entry = CreateSeqEntry(bssp, bsgp, bsmp, bsp->descr, nbp);
 
258
   
 
259
  if (IS_Bioseq(pdb_entry))
 
260
  {
 
261
    vnp = ValNodeFindNext(pdb_entry, NULL, 1);
 
262
    bioseqs[index] = (BioseqPtr) vnp->data.ptrvalue;
 
263
  }
 
264
  else
 
265
  {
 
266
    vnp = ValNodeFindNext(pdb_entry, NULL, 2);
 
267
    biossp = (BioseqSetPtr) vnp->data.ptrvalue;
 
268
    seq_set = biossp->seq_set;
 
269
      
 
270
    for (num_chain = 0; num_chain < nbp, seq_set; seq_set = seq_set->next, num_chain++, index++)
 
271
      bioseqs[index] = (BioseqPtr) seq_set->data.ptrvalue;
 
272
  }  
 
273
  
 
274
  dtp = (DbtagPtr)bssp->database_entry_id->data.ptrvalue;
 
275
   
 
276
  for (index = 0, currentbp = bp; index < nbp, currentbp != NULL; currentbp = currentbp->next, index++)
 
277
  {
 
278
     current_bioseq = bioseqs[index];
 
279
     if (currentbp->seq_id->choice == '\f')
 
280
     {
 
281
       current_bioseq->id = MakePDBId(bssp, currentbp, dtp);   
 
282
       sip = ValNodeNew(NULL);
 
283
       sip->choice = SEQID_GI;
 
284
       sip->data.intvalue = currentbp->seq_id->data.intvalue;
 
285
       current_bioseq->id->next = sip;
 
286
     }
 
287
     else if (currentbp->seq_id->choice == SEQID_LOCAL)
 
288
       current_bioseq->id = MakeLocalID(-99999, currentbp, dtp);
 
289
     current_bioseq->descr = MakeBioseqDescr(currentbp, current_bioseq->descr);
 
290
     current_bioseq->mol = MakeBioseqMol(currentbp);
 
291
     current_bioseq->length = CountNumOfResidues(currentbp);
 
292
     
 
293
     if (current_bioseq->mol == Seq_mol_aa)
 
294
        current_bioseq->seq_data_type = Seq_code_iupacaa;
 
295
     else
 
296
        current_bioseq->seq_data_type = Seq_code_iupacna;
 
297
     
 
298
     current_bioseq->seq_data = AddSeqData(currentbp, current_bioseq->mol, current_bioseq->length, bsgp, stdDictionary);
 
299
     current_bioseq->annot = AddNstdSeqAnnot(currentbp, current_bioseq->id, bsgp);
 
300
   }  
 
301
   /* Add information about Secondary Structure and Domains */
 
302
  for (bsfsp = bsp->features, DomainNum = 0; bsfsp; bsfsp = bsfsp->next)
 
303
  {
 
304
    if (vnp = ValNodeFindNext(bsfsp->descr, NULL, BiostrucFeatureSetDescr_name))
 
305
       feature_name = vnp->data.ptrvalue;
 
306
     
 
307
    if ((!StringICmp("NCBI assigned secondary structure", feature_name)) ||
 
308
       (!StringICmp("NCBI Domains", feature_name)))
 
309
    {
 
310
      for (bsfp = bsfsp->features; bsfp; bsfp = bsfp->next)
 
311
      {
 
312
        cgpp = (ChemGraphPntrsPtr)bsfp->Location_location->data.ptrvalue;
 
313
        rpp = (ResiduePntrsPtr)cgpp->data.ptrvalue;
 
314
        ripp = (ResidueIntervalPntrPtr)rpp->data.ptrvalue;
 
315
        chnidx = findChnidx(ripp->molecule_id, nbp, bp);
 
316
        current_bioseq = bioseqs[chnidx-1];
 
317
        
 
318
        if (!StringICmp("NCBI Domains", feature_name)) DomainNum++;
 
319
        
 
320
        if (current_bioseq->annot)
 
321
          current_bioseq->annot = AddSecDomToSeqAnnot(bsfp, feature_name, current_bioseq->annot, current_bioseq->id, DomainNum);
 
322
        else
 
323
          current_bioseq->annot = AddSecDomToSeqAnnot(bsfp, feature_name, NULL, current_bioseq->id, DomainNum); 
 
324
      }
 
325
    }
 
326
  }
 
327
  for (index = 0, currenthet = het; index < nhet, currenthet; currenthet = currenthet->next, index++)
 
328
  {
 
329
    hetval = MakeHetValNode(currenthet, stdDictionary, bsgp->residue_graphs);
 
330
    bioseq_idx = 0;
 
331
    interchain = FALSE;
 
332
 
 
333
    for (abp = bsgp->inter_molecule_bonds, bonds = FALSE, rescount = 0; abp; abp = abp->next)
 
334
    {
 
335
      molId1 = abp->atom_id_1->molecule_id;
 
336
      molId2 = abp->atom_id_2->molecule_id;
 
337
      resId1 = abp->atom_id_1->residue_id;
 
338
      resId2 = abp->atom_id_2->residue_id;
 
339
      atmId1 = abp->atom_id_1->atom_id;
 
340
      atmId2 = abp->atom_id_2->atom_id;
 
341
      
 
342
      if (isBiopoly(molId1, bp) && isHet(molId2, het))
 
343
      {
 
344
        bpchnidx = molId1 - 1;
 
345
        bpresidx = resId1 - 1;
 
346
        hetidx = getHetIdx(molId2, het);
 
347
        bonds = TRUE;
 
348
      }
 
349
      else if (isBiopoly(molId2, bp) && isHet(molId1, het))
 
350
      {
 
351
        bpchnidx = molId2 - 1;
 
352
        bpresidx = resId2 - 1;
 
353
        hetidx = getHetIdx(molId1, het);
 
354
        bonds = TRUE;
 
355
      }
 
356
      
 
357
      if (bonds)
 
358
      {
 
359
        if (hetidx == index)
 
360
        {
 
361
          if (!rescount) pvnThePoints = NULL;
 
362
          ValNodeAddInt(&pvnThePoints, 0, bpresidx);
 
363
          rescount++;
 
364
          if (bioseq_idx >= 0)
 
365
          {
 
366
             if (bioseq_idx != bpchnidx) interchain = TRUE;
 
367
          }
 
368
          bioseq_idx = bpchnidx;
 
369
        }
 
370
      }
 
371
    }
 
372
    
 
373
    if (rescount)
 
374
    {  
 
375
      if (!interchain)
 
376
      {
 
377
        current_bioseq = bioseqs[bioseq_idx];
 
378
        if (current_bioseq->annot)
 
379
          current_bioseq->annot = AddHetToSeqAnnot(current_bioseq->annot, current_bioseq->id, hetval, pvnThePoints, rescount);
 
380
        else
 
381
          current_bioseq->annot = AddHetToSeqAnnot(NULL, current_bioseq->id, hetval, pvnThePoints, rescount); 
 
382
      }
 
383
      if (interchain)
 
384
      {
 
385
        if (IS_Bioseq(pdb_entry))
 
386
          sap = ((BioseqPtr)(pdb_entry->data.ptrvalue))->annot;
 
387
        else
 
388
          sap = ((BioseqSetPtr)(pdb_entry->data.ptrvalue))->annot;
 
389
        if (sap == NULL)
 
390
        {
 
391
          sap = SeqAnnotNew();
 
392
          sap->type = 1;
 
393
          if (IS_Bioseq(pdb_entry))
 
394
            ((BioseqPtr)(pdb_entry->data.ptrvalue))->annot = sap;
 
395
          else
 
396
            ((BioseqSetPtr)(pdb_entry->data.ptrvalue))->annot = sap;
 
397
         }
 
398
         sap = AddHetToSeqAnnot(sap, bioseqs[bioseq_idx]->id, hetval, pvnThePoints, rescount);
 
399
      }
 
400
    }
 
401
    else
 
402
    {
 
403
      current_bioseq = bioseqs[bioseq_idx];
 
404
      vnp = current_bioseq->descr;
 
405
      if (vnp != NULL)
 
406
      { 
 
407
        while (vnp->next != NULL) vnp = vnp->next;
 
408
        vnp->next = hetval;
 
409
      }
 
410
      else current_bioseq->descr = hetval;
 
411
    }
 
412
  }      
 
413
  
 
414
  mgp = bsgp->molecule_graphs;
 
415
  abp = bsgp->inter_molecule_bonds;
 
416
  
 
417
  while(1)
 
418
  {
 
419
    if (mgp != NULL)
 
420
    { 
 
421
      currentabp = mgp->inter_residue_bonds;
 
422
      mgp = mgp->next;
 
423
    }
 
424
    
 
425
    while (currentabp != NULL)
 
426
    {
 
427
      molId1 = currentabp->atom_id_1->molecule_id;
 
428
      molId2 = currentabp->atom_id_2->molecule_id;
 
429
      resId1 = currentabp->atom_id_1->residue_id;
 
430
      resId2 = currentabp->atom_id_2->residue_id;
 
431
      atmId1 = currentabp->atom_id_1->atom_id;
 
432
      atmId2 = currentabp->atom_id_2->atom_id;
 
433
 
 
434
      interchain = FALSE;
 
435
      found1 = FALSE;
 
436
      found2 = FALSE;
 
437
 
 
438
      if ((getAtomElementIdx(molId1, resId1, atmId1, bsgp, stdDictionary)==16) 
 
439
         && (getAtomElementIdx(molId2, resId2, atmId2, bsgp, stdDictionary)==16))
 
440
      { 
 
441
         /* Found possible disulfide bonds. */
 
442
 
 
443
        if (isBiopoly(molId1, bp) && isBiopoly(molId2, bp))  
 
444
        {
 
445
          currentbp = bp;
 
446
          for (index=0; index<findChnidx(molId1, nbp, bp)-1; index++)
 
447
            currentbp = currentbp->next;
 
448
 
 
449
          rs = currentbp->residue_sequence;
 
450
 
 
451
           while (rs)
 
452
           {
 
453
             if (rs->id == resId1)
 
454
             {
 
455
               rgp = getResGraph(rs->residue_graph, bsgp, stdDictionary);
 
456
               break;
 
457
             }
 
458
           
 
459
            rs = rs->next;
 
460
           }
 
461
           
 
462
          if (vnp = ValNodeFindNext(rgp->descr, NULL, BiomolDescr_name))
 
463
             rname = vnp->data.ptrvalue;
 
464
                 
 
465
          if (!StringICmp(rname, "CYS")) found1 = TRUE;
 
466
 
 
467
          currentbp = bp;
 
468
          for (index = 0; index < findChnidx(molId2, nbp, bp)-1; index++)
 
469
             currentbp = currentbp->next;
 
470
 
 
471
          rs = currentbp->residue_sequence;
 
472
 
 
473
          while (rs)
 
474
          {
 
475
            if (rs->id == resId2)
 
476
            {
 
477
              rgp = getResGraph(rs->residue_graph, bsgp, stdDictionary);
 
478
              break;
 
479
             }
 
480
 
 
481
            rs = rs->next;
 
482
          }
 
483
 
 
484
          if (vnp = ValNodeFindNext(rgp->descr, NULL, BiomolDescr_name))
 
485
            rname = vnp->data.ptrvalue;
 
486
 
 
487
          if (!StringICmp(rname, "CYS")) found2 = TRUE;
 
488
 
 
489
          if (found1 && found2)
 
490
          {
 
491
            ssresidx1 = resId1 - 1;
 
492
            ssresidx2 = resId2 - 1;
 
493
            ssmolidx1 = molId1 - 1;
 
494
            ssmolidx2 = molId2 - 1;
 
495
            chnidx = findChnidx(molId1, nbp, bp);
 
496
            
 
497
            if (ssmolidx1 == ssmolidx2) 
 
498
            {
 
499
              current_bioseq = bioseqs[chnidx - 1];
 
500
              if (current_bioseq->annot)
 
501
                current_bioseq->annot = AddDisulToSeqAnnot(current_bioseq->annot, ssresidx1, ssresidx2, current_bioseq->id, current_bioseq->id);
 
502
              else
 
503
                current_bioseq->annot = AddDisulToSeqAnnot(NULL, ssresidx1, ssresidx2, current_bioseq->id, current_bioseq->id);
 
504
            }
 
505
            else
 
506
            {
 
507
              if (IS_Bioseq(pdb_entry))
 
508
                sap = ((BioseqPtr)(pdb_entry->data.ptrvalue))->annot;
 
509
              else
 
510
                sap = ((BioseqSetPtr)(pdb_entry->data.ptrvalue))->annot;
 
511
              if (sap == NULL)
 
512
              {
 
513
                sap = SeqAnnotNew();
 
514
                sap->type = 1;
 
515
                if (IS_Bioseq(pdb_entry))
 
516
                  ((BioseqPtr)(pdb_entry->data.ptrvalue))->annot = sap;
 
517
                else
 
518
                  ((BioseqSetPtr)(pdb_entry->data.ptrvalue))->annot = sap;
 
519
              }
 
520
              sap = AddDisulToSeqAnnot(sap, ssresidx1, ssresidx2, bioseqs[ssmolidx1]->id, bioseqs[ssmolidx2]->id);
 
521
            }   
 
522
          }
 
523
        }
 
524
      }   
 
525
      
 
526
      currentabp = currentabp->next;
 
527
    }
 
528
    
 
529
    if ((currentabp == NULL) && (mgp == NULL) && (abp == NULL)) break;
 
530
    
 
531
    else if((currentabp == NULL) && (mgp == NULL) && (abp != NULL))
 
532
    { 
 
533
      currentabp = abp;
 
534
      abp = NULL;
 
535
    }
 
536
  }
 
537
 
 
538
  return pdb_entry;
 
539
}
 
540
 
 
541