Bioplib
Protein Structure C Library
 All Data Structures Files Functions Variables Typedefs Macros Pages
deprecatedBiop.c
Go to the documentation of this file.
1 /************************************************************************/
2 /**
3 
4  \file deprecatedBiop.c
5 
6  \version V1.11
7  \date 24.08.15
8  \brief Source code for Biop deprecated functions.
9 
10  \copyright (c) UCL / Dr. Andrew C. R. Martin 2014-2015
11  \author Dr. Andrew C. R. Martin
12  \par
13  Institute of Structural & Molecular Biology,
14  University College London,
15  Gower Street,
16  London.
17  WC1E 6BT.
18  \par
19  andrew@bioinf.org.uk
20  andrew.martin@ucl.ac.uk
21 
22 **************************************************************************
23 
24  This code is NOT IN THE PUBLIC DOMAIN, but it may be copied
25  according to the conditions laid out in the accompanying file
26  COPYING.DOC.
27 
28  The code may be modified as required, but any modifications must be
29  documented so that the person responsible can be identified.
30 
31  The code may not be sold commercially or included as part of a
32  commercial product except as described in the file COPYING.DOC.
33 
34 **************************************************************************
35 
36  Description:
37  ============
38 
39  Allows code utilising BiopLib to compile without modification to use
40  function names with the 'bl' prefix.(The 'bl' prefix was introduced in
41  July 2014.)
42 
43  Allows use of deprecated functions that take a single character for the
44  PDB chain identifier or insert value.
45 
46 
47 **************************************************************************
48 
49  Usage:
50  ======
51 
52  Code using deprecated functions can be compiled without modification,
53  however, all deprecated functions use the DEPRECATED macro which prints
54  a warning message to stderr when a deprecated function is called.
55 
56  The warning message can be suppressed as either an option at the
57  compilation of the library or by setting an environment variable at
58  runtime.
59 
60  \par Documentation
61  Doxygen is not set to document deprecated functions. To document
62  deprecated functions, add "deprecated" to the ENABLED SECTIONS tag in
63  the Doxygen config file:
64  bioplib/doc/doxygen/Doxyfile
65 
66 **************************************************************************
67 
68  Revision History:
69  =================
70 
71 - V1.0 31.07.14 Original By: CTP
72 - V1.1 08.08.14 Separated Biop and Gen deprecation By: ACRM
73 - V1.2 14.08.14 Removed unnecessary includes. By: CTP
74 - V1.3 19.08.14 Renamed functions: blBuildAtomNeighbourPDBList(),
75  blExtractZonePDB(), blSelectAtomsPDB(), blStripHPDB(),
76  blStripWatersPDB() with AsCopy suffix. By: CTP
77 - V1.4 26.08.14 Added blSetMDMScoreWeight() By: ACRM
78 - V1.5 24.10.14 Added blExtractZoneSpecPDBAsCopy()
79 - V1.6 23.02.15 blWritePDBTrailier() and blRenumAtomsPDB() now take
80  additional parameters
81 - V1.7 24.02.15 WritePDB() points to blWritePDB() instead of
82  blWriteAsPDB() (which is now blWritePDBAsPDBorGromos())
83 - V1.8 02.03.15 blGetExptl() is now called blGetExptlPDB()
84 - V1.9 05.03.15 Removed blFindEndPDB() as FindEndPDB() is deprecated
85  and replaced by FindNextResidure()/blFindNextResidue()
86 - V1.10 28.04.15 Updated doReadPDBML() for latest version of
87  blDoReadPDBML(). By: CTP
88 - V1.11 24.08.15 IsHBonded() wasn't deprecated properly
89 
90 *************************************************************************/
91 /* Includes
92 */
93 #include "deprecated.h"
94 
95 #include "pdb.h"
96 #include "aalist.h"
97 #include "cssr.h"
98 #include "fit.h"
99 #include "hbond.h"
100 #include "seq.h"
101 
102 
103 /************************************************************************/
104 /* Defines and macros
105 */
106 
107 /************************************************************************/
108 /* Globals
109 */
110 
111 /************************************************************************/
112 /* Prototypes
113 */
114 
115 
116 
117 /************************************************************************/
118 /** \cond deprecated */
119 
120 
121 /************************************************************************/
122 /*>PDB *FindHetatmResidue(PDB *pdb, char chain, int resnum, char insert)
123  ---------------------------------------------------------------------
124 *//**
125 
126  Finds a pointer to the start of a residue in a PDB linked list, but
127  requires the residue is a HETATM record.
128  Uses char for chain and insert.
129 
130 - 26.10.11 Original By: ACRM
131 - 24.02.14 Converted into wrapper for BiopFindHetatmResidue(). By: CTP
132 - 25.02.14 Added error message. By: CTP
133 - 07.05.14 Converted to macro. By: CTP
134 - 07.07.14 Use bl prefix for functions By: CTP
135 - 31.07.14 Moved to deprecated.c and converted from macro to function.
136  By: CTP
137 */
138 PDB *FindHetatmResidue(PDB *pdb, char chain, int resnum, char insert)
139 {
140  char chain_a[2] = " ",
141  insert_a[2] = " ";
142 
143  DEPRECATED("FindHetatmResidue()","blFindHetatmResidue()");
144 
145  chain_a[0] = chain;
146  insert_a[0] = insert;
147 
148  return(blFindHetatmResidue(pdb, chain_a, resnum, insert_a));
149 
150 }
151 
152 
153 /************************************************************************/
154 /*>PDB *FindResidue(PDB *pdb, char chain, int resnum, char insert)
155  ---------------------------------------------------------------
156 *//**
157 
158  Finds a pointer to the start of a residue in a PDB linked list.
159  Uses char for string and insert.
160 
161 - 06.02.96 Original By: ACRM
162 - 24.02.14 Converted into wrapper for BiopFindResidue(). By: CTP
163 - 25.02.14 Added error message. By: CTP
164 - 07.05.14 Converted to macro. By: CTP
165 - 07.07.14 Use bl prefix for functions By: CTP
166 - 31.07.14 Moved to deprecated.c and converted from macro to function.
167  By: CTP
168 */
169 
170 PDB *FindResidue(PDB *pdb, char chain, int resnum, char insert)
171 {
172  char chain_a[2] = " ",
173  insert_a[2] = " ";
174 
175  DEPRECATED("FindResidue()","blFindResidue()");
176 
177  chain_a[0] = chain;
178  insert_a[0] = insert;
179 
180  return(blFindResidue(pdb, chain_a, resnum, insert_a));
181 }
182 
183 
184 /************************************************************************/
185 /*>BOOL FindZonePDB(PDB *pdb, int start, char startinsert, int stop,
186  char stopinsert, char chain, int mode,
187  PDB **pdb_start, PDB **pdb_stop)
188  -------------------------------------------------------------
189 *//**
190 
191  \param[in] *pdb PDB linked list
192  \param[in] start Resnum of start of zone
193  \param[in] startinsert Insert code for start of zone
194  \param[in] stop Resnum of end of zone
195  \param[in] stopinsert Insert code for end of zone
196  \param[in] chain Chain name
197  \param[in] mode ZONE_MODE_RESNUM: Use PDB residue
198  numbers/chain
199  ZONE_MODE_SEQUENTIAL: Use sequential
200  numbering
201  \param[out] **pdb_start Start of zone
202  \param[out] **pdb_stop End of zone
203  \return OK?
204 
205  Finds pointers to the start and end of a zone in a PDB linked list. The
206  end is the atom *after* the specified zone
207 
208 - 30.09.92 Original
209 - 17.07.95 Chain name was being ignored in specs like L* (for whole
210  of light chain)
211 - 18.08.95 Now handles inserts
212 - 31.07.95 Fixed bug when zone end==chain end
213 - 20.02.01 Changed to -999/-999 for beginning/end of chain rather than -1/-1
214 - 20.03.14 Function deprecated. Converted to wrapper for blFindZonePDB()
215  By: CTP
216 - 07.05.14 Converted to macro. By: CTP
217 - 31.07.14 Moved to deprecated.c and converted from macro to function.
218  By: CTP
219 */
220 BOOL FindZonePDB(PDB *pdb, int start, char startinsert, int stop,
221  char stopinsert, char chain, int mode, PDB **pdb_start,
222  PDB **pdb_stop)
223 {
224  char startinsert_a[2] = " ",
225  stopinsert_a[2] = " ",
226  chain_a[2] = " ";
227 
228  DEPRECATED("FindZonePDB()","blFindZonePDB()");
229 
230  strncpy(startinsert_a,&startinsert,1);
231  strncpy(stopinsert_a ,&stopinsert ,1);
232  strncpy(chain_a ,&chain ,1);
233 
234  return(blFindZonePDB(pdb,
235  start,
236  startinsert_a,
237  stop,
238  stopinsert_a,
239  chain_a,
240  mode,
241  pdb_start,
242  pdb_stop));
243 }
244 
245 
246 /************************************************************************/
247 /*>BOOL InPDBZone(PDB *p, char chain, int resnum1, char insert1,
248  int resnum2, char insert2)
249  ----------------------------------------------------------
250 *//**
251 
252  \param[in] *p Pointer to a PDB record
253  \param[in] chain Chain name
254  \param[in] resnum1 First residue
255  \param[in] insert1 First insert code
256  \param[in] resnum2 Second residue
257  \param[in] insert2 Second insert code
258  \return Is p in the range specified?
259 
260  Checks that atom stored in PDB pointer p is within the specified
261  residue range.
262 
263  N.B. This assumes ASCII coding.
264 
265 - 29.03.95 Original By: ACRM
266 - 08.02.96 Insert residues inside a zone were not handled correctly!
267 - 18.06.96 Added to bioplib from QTree (was called InZone())
268 - 24.02.14 Converted into wrapper for BiopInPDBZone() By: CTP
269 - 25.02.14 Added error message. By: CTP
270 - 07.05.14 Converted to macro. By: CTP
271 - 07.07.14 Use bl prefix for functions By: CTP
272 - 31.07.14 Moved to deprecated.c and converted from macro to function.
273  By: CTP
274 */
275 BOOL InPDBZone(PDB *p, char chain, int resnum1, char insert1,
276  int resnum2, char insert2)
277 {
278  char chain_a[2] = " ",
279  insert1_a[2] = " ",
280  insert2_a[2] = " ";
281 
282  DEPRECATED("InPDBZone()","blInPDBZone()");
283 
284  chain_a[0] = chain;
285  insert1_a[0] = insert1;
286  insert2_a[0] = insert2;
287 
288  return(blInPDBZone(p,chain_a,resnum1,insert1_a,resnum2, insert2_a));
289 }
290 
291 /************************************************************************/
292 /*>void WritePDB(FILE *fp, PDB *pdb)
293  ---------------------------------
294 *//**
295 
296  \param[in] *fp PDB file pointer to be written
297  \param[in] *pdb PDB linked list to write
298 
299  Write a PDB linked list by calls to WritePDBRecord()
300 
301 - 08.03.89 Original
302 - 01.06.92 ANSIed and autodoc'd
303 - 10.06.93 Uses NEXT macro; void type
304 - 08.07.93 Added insertion of TER cards
305 - 22.02.94 And a TER card at the end of the file
306 - 04.02.14 Use CHAINMATCH macro. By: CTP
307 - 21.06.14 Function deprecated. Converted to wrapper for blWriteAsPDB().
308  By: CTP
309 - 31.07.14 Moved to deprecated.c and converted from macro to function.
310  By: CTP
311 - 24.02.15 Now calls blWritePDB()
312 */
313 void WritePDB(FILE *fp, PDB *pdb)
314 {
315  DEPRECATED("WritePDB","blWritePDB()");
316  blWritePDB(fp, pdb);
317 }
318 
319 /************************************************************************/
320 /*>void WriteWholePDB(FILE *fp, WHOLEPDB *wpdb)
321  --------------------------------------------
322 *//**
323 
324  \param[in] *fp File pointer
325  \param[in] *wpdb Whole PDB structure pointer
326 
327  Writes a PDB file including header and trailer information
328 
329 - 30.05.02 Original By: ACRM
330 - 21.06.14 Deprecated function. By CTP.
331 - 07.07.14 Use bl prefix for functions. Moved to deprecated.h By: CTP
332 - 31.07.14 Moved to deprecated.c and converted from macro to function.
333  By: CTP
334 - 04.03.15 Changed to use blWritePDBAsPDBorGromos() and to count TER
335  cards
336 */
337 void WriteWholePDB(FILE *fp, WHOLEPDB *wpdb)
338 {
339  int numTer;
340  DEPRECATED("WriteWholePDB","blWriteWholePDB()");
341 
342  if((wpdb!=NULL) && (wpdb->pdb!=NULL))
343  {
344  blWriteWholePDBHeader(fp, wpdb);
345  numTer = blWritePDBAsPDBorGromos(fp, wpdb->pdb, FALSE);
346  blWriteWholePDBTrailer(fp, wpdb, numTer);
347  }
348 }
349 
350 
351 /************************************************************************/
352 /*>void WriteWholePDBHeader(FILE *fp, WHOLEPDB *wpdb)
353  --------------------------------------------------
354 *//**
355 
356  \param[in] *fp File pointer
357  \param[in] *wpdb Whole PDB structure pointer
358 
359  Writes the header of a PDB file
360 
361 - 30.05.02 Original By: ACRM
362 - 21.06.14 Deprecated By: CTP
363 - 07.07.14 Moved to deprecated.h By: CTP
364 - 31.07.14 Moved to deprecated.c and converted from macro to function.
365  By: CTP
366 */
367 void WriteWholePDBHeader(FILE *fp, WHOLEPDB *wpdb)
368 {
369  DEPRECATED("WriteWholePDBHeader()","blWriteWholePDBHeader()");
370  blWriteWholePDBHeader(fp, wpdb);
371 }
372 
373 
374 /************************************************************************/
375 /*>void WriteWholePDBTrailer(FILE *fp, WHOLEPDB *wpdb)
376  ---------------------------------------------------
377 *//**
378 
379  \param[in] *fp File pointer
380  \param[in] *wpdb Whole PDB structure pointer
381 
382  Writes the trailer of a PDB file
383 
384 - 30.05.02 Original By: ACRM
385 - 21.06.14 Deprecated By: CTP
386 - 07.07.14 Moved to deprecated.h By: CTP
387 - 31.07.14 Moved to deprecated.c and converted from macro to function.
388  By: CTP
389 */
390 void WriteWholePDBTrailer(FILE *fp, WHOLEPDB *wpdb)
391 {
392  DEPRECATED("WriteWholePDBTrailer()","blWriteWholePDBTrailer()");
393  blWriteWholePDBTrailer(fp, wpdb, 0);
394 }
395 
396 
397 /************************************************************************/
398 /*>char *GetPDBChainLabels(PDB *pdb)
399  ---------------------------------
400 *//**
401 
402  \param[in] *pdb PDB linked list
403  \return Allocated string containing chain labels
404  NULL if unable to allocate memory
405 
406  Scans a PDB linked list for chain names. Allocates memory for a
407  string containing these labels which is returned.
408 
409  N.B. You must free the allocated memory when you've finished with it!
410 
411 - 25.07.95 Original By: ACRM
412 - 25.03.14 Added deprecated message. By: CTP
413 - 07.05.14 Use DEPRECATED() macro. By: CTP
414 - 31.07.14 Moved to deprecated.c By: CTP
415 */
416 char *GetPDBChainLabels(PDB *pdb)
417 {
418  char *chains;
419  int nchains = 0,
420  maxchains = 16;
421  PDB *p;
422 
423  DEPRECATED("GetPDBChainLabels()","blGetPDBChainLabels()");
424 
425  /* Just return if linked list is NULL */
426  if(pdb==NULL)
427  return(NULL);
428 
429  /* Allocate a chunk for storing the chains */
430  if((chains = (char *)malloc(maxchains * sizeof(char)))==NULL)
431  return(NULL);
432 
433  /* Set up first chain label */
434  chains[nchains] = pdb->chain[0];
435 
436  /* Run through the linked list */
437  for(p=pdb; p!=NULL; NEXT(p))
438  {
439  /* If chain label has changed */
440  if(p->chain[0] != chains[nchains])
441  {
442  /* Increment chain count and reallocate memory if needed */
443  if(++nchains == maxchains)
444  {
445  maxchains += 16;
446  if((chains = realloc(chains, maxchains * sizeof(char)))==NULL)
447  return(NULL);
448  }
449  /* Store this new chain label */
450  chains[nchains] = p->chain[0];
451  }
452  }
453 
454  /* Increment chain count and reallocate memory if needed */
455  if(++nchains == maxchains)
456  {
457  maxchains += 16;
458  if((chains = realloc(chains, maxchains * sizeof(char)))==NULL)
459  return(NULL);
460  }
461 
462  /* Terminate the chain list with a NUL character */
463  chains[nchains] = '\0';
464 
465  return(chains);
466 }
467 
468 
469 
470 /************************************************************************/
471 /* Renamed functions: pdb.h */
472 
473 PDB *ReadPDB(FILE *fp, int *natom)
474 {
475  DEPRECATED("ReadPDB()","blReadPDB()");
476  return(blReadPDB(fp, natom));
477 }
478 
479 PDB *ReadPDBAll(FILE *fp, int *natom)
480 {
481  DEPRECATED("ReadPDBAll()","blReadPDBAll()");
482  return(blReadPDBAll(fp, natom));
483 }
484 
485 PDB *ReadPDBAtoms(FILE *fp, int *natom)
486 {
487  DEPRECATED("ReadPDBAtoms()","blReadPDBAtoms()");
488  return(blReadPDBAtoms(fp, natom));
489 }
490 
491 PDB *ReadPDBOccRank(FILE *fp, int *natom, int OccRank)
492 {
493  DEPRECATED("ReadPDBOccRank()","blReadPDBOccRank()");
494  return(blReadPDBOccRank(fp, natom, OccRank));
495 }
496 
497 PDB *ReadPDBAtomsOccRank(FILE *fp, int *natom, int OccRank)
498 {
499  DEPRECATED("ReadPDBAtomsOccRank()","blReadPDBAtomsOccRank()");
500  return(blReadPDBAtomsOccRank(fp, natom, OccRank));
501 }
502 
503 PDB *doReadPDB(FILE *fp, int *natom, BOOL AllAtoms, int OccRank,
504  int ModelNum)
505 {
506  WHOLEPDB *wpdb;
507  *natom = 0;
508 
509  DEPRECATED("doReadPDB()","blDoReadPDB()");
510  if(((wpdb = blDoReadPDB(fp, AllAtoms, OccRank, ModelNum, FALSE))==NULL)
511  || (wpdb->pdb == NULL))
512  return(NULL);
513 
514  *natom = wpdb->natoms;
515  return(wpdb->pdb);
516 }
517 
518 PDB *doReadPDBML(FILE *fp, int *natom, BOOL AllAtoms, int OccRank,
519  int ModelNum)
520 {
521 /*
522  DEPRECATED("doReadPDBML()","blDoReadPDBML()");
523  return(blDoReadPDBML(fp, natom, AllAtoms, OccRank, ModelNum));
524 */
525  WHOLEPDB *wpdb;
526  *natom = 0;
527 
528  DEPRECATED("doReadPDBML()","blDoReadPDBML()");
529  if(((wpdb = blDoReadPDBML(fp, AllAtoms, OccRank, ModelNum, FALSE))==NULL)
530  || (wpdb->pdb == NULL))
531  return(NULL);
532 
533  *natom = wpdb->natoms;
534  return(wpdb->pdb);
535 
536 
537 }
538 
539 BOOL CheckFileFormatPDBML(FILE *fp)
540 {
541  DEPRECATED("CheckFileFormatPDBML()","blCheckFileFormatPDBML()");
542  return(blCheckFileFormatPDBML(fp));
543 }
544 
545 void WriteAsPDB(FILE *fp, PDB *pdb)
546 {
547  DEPRECATED("WriteAsPDB()","blWritePDBAsPDBorGromos()");
548  blWritePDBAsPDBorGromos(fp, pdb, FALSE);
549 }
550 
551 void WriteAsPDBML(FILE *fp, PDB *pdb)
552 {
553  DEPRECATED("WriteAsPDBML()","blWritePDBAsPDBML()");
554  blWritePDBAsPDBML(fp, pdb);
555 }
556 
557 BOOL FormatCheckWritePDB(PDB *pdb)
558 {
559  DEPRECATED("FormatCheckWritePDB()","blFormatCheckWritePDB()");
560  return(blFormatCheckWritePDB(pdb));
561 }
562 
563 void WritePDBRecord(FILE *fp, PDB *pdb)
564 {
565  DEPRECATED("WritePDBRecord()","blWritePDBRecord()");
566  blWritePDBRecord(fp, pdb);
567 }
568 
569 void WritePDBRecordAtnam(FILE *fp, PDB *pdb)
570 {
571  DEPRECATED("WritePDBRecordAtnam()","blWritePDBRecordAtnam()");
572  blWritePDBRecordAtnam(fp, pdb);
573 }
574 
575 void WriteGromosPDB(FILE *fp, PDB *pdb)
576 {
577  DEPRECATED("WriteGromosPDB()","blWriteGromosPDB()");
578  blWriteGromosPDB(fp, pdb);
579 }
580 
581 void WriteGromosPDBRecord(FILE *fp, PDB *pdb)
582 {
583  DEPRECATED("WriteGromosPDBRecord()","blWriteGromosPDBRecord()");
584  blWriteGromosPDBRecord(fp, pdb);
585 }
586 
587 void GetCofGPDB(PDB *pdb, VEC3F *cg)
588 {
589  DEPRECATED("GetCofGPDB()","blGetCofGPDB()");
590  blGetCofGPDB(pdb, cg);
591 }
592 
593 void GetCofGPDBRange(PDB *start, PDB *stop, VEC3F *cg)
594 {
595  DEPRECATED("GetCofGPDBRange()","blGetCofGPDBRange()");
596  blGetCofGPDBRange(start, stop, cg);
597 }
598 
599 void GetCofGPDBSCRange(PDB *start, PDB *stop, VEC3F *cg)
600 {
601  DEPRECATED("GetCofGPDBSCRange()","blGetCofGPDBSCRange()");
602  blGetCofGPDBSCRange(start, stop, cg);
603 }
604 
605 void OriginPDB(PDB *pdb)
606 {
607  DEPRECATED("OriginPDB()","blOriginPDB()");
608  blOriginPDB(pdb);
609 }
610 
611 void RotatePDB(PDB *pdb, REAL rm[3][3])
612 {
613  DEPRECATED("RotatePDB()","blRotatePDB()");
614  blRotatePDB(pdb, rm);
615 }
616 
617 void TranslatePDB(PDB *pdb, VEC3F tvect)
618 {
619  DEPRECATED("TranslatePDB()","blTranslatePDB()");
620  blTranslatePDB(pdb, tvect);
621 }
622 
623 BOOL FitPDB(PDB *ref_pdb, PDB *fit_pdb, REAL rm[3][3])
624 {
625  DEPRECATED("FitPDB()","blFitPDB()");
626  return(blFitPDB(ref_pdb, fit_pdb, rm));
627 }
628 
629 BOOL FitCaPDB(PDB *ref_pdb, PDB *fit_pdb, REAL rm[3][3])
630 {
631  DEPRECATED("FitCaPDB()","blFitCaPDB()");
632  return(blFitCaPDB(ref_pdb, fit_pdb, rm));
633 }
634 
635 BOOL FitNCaCPDB(PDB *ref_pdb, PDB *fit_pdb, REAL rm[3][3])
636 {
637  DEPRECATED("FitNCaCPDB()","blFitNCaCPDB()");
638  return(blFitNCaCPDB(ref_pdb, fit_pdb, rm));
639 }
640 
641 BOOL FitCaCbPDB(PDB *ref_pdb, PDB *fit_pdb, REAL rm[3][3])
642 {
643  DEPRECATED("FitCaCbPDB()","blFitCaCbPDB()");
644  return(blFitCaCbPDB(ref_pdb, fit_pdb, rm));
645 }
646 
647 REAL CalcRMSPDB(PDB *pdb1, PDB *pdb2)
648 {
649  DEPRECATED("CalcRMSPDB()","blCalcRMSPDB()");
650  return(blCalcRMSPDB(pdb1, pdb2));
651 }
652 
653 int GetPDBCoor(PDB *pdb, COOR **coor)
654 {
655  DEPRECATED("GetPDBCoor()","blGetPDBCoor()");
656  return(blGetPDBCoor(pdb, coor));
657 }
658 
659 int HAddPDB(FILE *fp, PDB *pdb)
660 {
661  DEPRECATED("HAddPDB()","blHAddPDB()");
662  return(blHAddPDB(fp, pdb));
663 }
664 
665 int ReadPGP(FILE *fp)
666 {
667  DEPRECATED("ReadPGP()","blReadPGP()");
668  return(blReadPGP(fp));
669 }
670 
671 FILE *OpenPGPFile(char *pgpfile, BOOL AllHyd)
672 {
673  DEPRECATED("OpenPGPFile()","blOpenPGPFile()");
674  return(blOpenPGPFile(pgpfile, AllHyd));
675 }
676 
677 PDB *SelectAtomsPDB(PDB *pdbin, int nsel, char **sel, int *natom)
678 {
679  DEPRECATED("SelectAtomsPDB()","blSelectAtomsPDBAsCopy()");
680  return(blSelectAtomsPDBAsCopy(pdbin, nsel, sel, natom));
681 }
682 
683 PDB *StripHPDB(PDB *pdbin, int *natom)
684 {
685  DEPRECATED("StripHPDB()","blStripHPDBAsCopy()");
686  return(blStripHPDBAsCopy(pdbin, natom));
687 }
688 
689 SECSTRUC *ReadSecPDB(FILE *fp, int *nsec)
690 {
691  DEPRECATED("ReadSecPDB()","blReadSecPDB()");
692  return(blReadSecPDB(fp, nsec));
693 }
694 
695 void RenumAtomsPDB(PDB *pdb)
696 {
697  DEPRECATED("RenumAtomsPDB()","blRenumAtomsPDB()");
698  blRenumAtomsPDB(pdb, 1);
699 }
700 
701 PDB *FindEndPDB(PDB *start)
702 {
703  DEPRECATED("FindEndPDB()","blFindNextResidue()");
704  return(blFindNextResidue(start));
705 }
706 
707 PDB *FixOrderPDB(PDB *pdb, BOOL Pad, BOOL Renum)
708 {
709  DEPRECATED("FixOrderPDB()","blFixOrderPDB()");
710  return(blFixOrderPDB(pdb, Pad, Renum));
711 }
712 
713 PDB *ShuffleResPDB(PDB *start, PDB *end, BOOL Pad)
714 {
715  DEPRECATED("ShuffleResPDB()","blShuffleResPDB()");
716  return(blShuffleResPDB(start, end, Pad));
717 }
718 
719 BOOL GetAtomTypes(char *resnam, char **AtomTypes)
720 {
721  DEPRECATED("GetAtomTypes()","blGetAtomTypes()");
722  return(blGetAtomTypes(resnam, AtomTypes));
723 }
724 
725 PDB *KillPDB(PDB *pdb, PDB *prev)
726 {
727  DEPRECATED("KillPDB()","blKillPDB()");
728  return(blKillPDB(pdb, prev));
729 }
730 
731 void CopyPDB(PDB *out, PDB *in)
732 {
733  DEPRECATED("CopyPDB()","blCopyPDB()");
734  blCopyPDB(out, in);
735 }
736 
737 BOOL MovePDB(PDB *move, PDB **from, PDB **to)
738 {
739  DEPRECATED("MovePDB()","blMovePDB()");
740  return(blMovePDB(move, from, to));
741 }
742 
743 PDB *AppendPDB(PDB *first, PDB *second)
744 {
745  DEPRECATED("AppendPDB()","blAppendPDB()");
746  return(blAppendPDB(first, second));
747 }
748 
749 PDB *ShuffleBB(PDB *pdb)
750 {
751  DEPRECATED("ShuffleBB()","blShuffleBB()");
752  return(blShuffleBB(pdb));
753 }
754 
755 REAL CalcChi(PDB *pdb, int type)
756 {
757  DEPRECATED("CalcChi()","blCalcChi()");
758  return(blCalcChi(pdb, type));
759 }
760 
761 PDB *GetPDBByN(PDB *pdb, int n)
762 {
763  DEPRECATED("GetPDBByN()","blGetPDBByN()");
764  return(blGetPDBByN(pdb, n));
765 }
766 
767 void SetChi(PDB *pdb, PDB *next, REAL chi, int type)
768 {
769  DEPRECATED("SetChi()","blSetChi()");
770  blSetChi(pdb, next, chi, type);
771 }
772 
773 BOOL KillSidechain(PDB *ResStart, PDB *NextRes, BOOL doCB)
774 {
775  DEPRECATED("KillSidechain()","blKillSidechain()");
776  return(blKillSidechain(ResStart, NextRes, doCB));
777 }
778 
779 void SetResnam(PDB *ResStart, PDB *NextRes, char *resnam, int resnum,
780  char *insert, char *chain)
781 {
782  DEPRECATED("SetResnam()","blSetResnam()");
783  blSetResnam(ResStart, NextRes, resnam, resnum, insert, chain);
784 }
785 
786 void ApplyMatrixPDB(PDB *pdb, REAL matrix[3][3])
787 {
788  DEPRECATED("ApplyMatrixPDB()","blApplyMatrixPDB()");
789  blApplyMatrixPDB(pdb, matrix);
790 }
791 
792 BOOL GetResolPDB(FILE *fp, REAL *resolution, REAL *RFactor,
793  int *StrucType)
794 {
795  DEPRECATED("GetResolPDB()","blGetResolPDB()");
796  return(blGetResolPDB(fp, resolution, RFactor, StrucType));
797 }
798 
799 BOOL GetExptl(FILE *fp, REAL *resolution, REAL *RFactor, REAL *FreeR,
800  int *StrucType)
801 {
802  DEPRECATED("GetExptl()","blGetExptlPDB()");
803  return(blGetExptlPDB(fp, resolution, RFactor, FreeR, StrucType));
804 }
805 
806 BOOL GetExptlOld(FILE *fp, REAL *resolution, REAL *RFactor, REAL *FreeR,
807  int *StrucType)
808 {
809  DEPRECATED("GetExptlOld()","blGetExptlOld()");
810  return(blGetExptlOld(fp, resolution, RFactor, FreeR, StrucType));
811 }
812 
813 char *ReportStructureType(int type)
814 {
815  DEPRECATED("ReportStructureType()","blReportStructureType()");
816  return(blReportStructureType(type));
817 }
818 
819 PDB **IndexPDB(PDB *pdb, int *natom)
820 {
821  DEPRECATED("IndexPDB()","blIndexPDB()");
822  return(blIndexPDB(pdb, natom));
823 }
824 
825 DISULPHIDE *ReadDisulphidesPDB(FILE *fp, BOOL *error)
826 {
827  DEPRECATED("ReadDisulphidesPDB()","blReadDisulphidesPDB()");
828  return(blReadDisulphidesPDB(fp, error));
829 }
830 
831 BOOL ParseResSpec(char *spec, char *chain, int *resnum, char *insert)
832 {
833  DEPRECATED("ParseResSpec()","blParseResSpec()");
834  return(blParseResSpec(spec, chain, resnum, insert));
835 }
836 
837 BOOL ParseResSpecNoUpper(char *spec, char *chain, int *resnum,
838  char *insert)
839 {
840  DEPRECATED("ParseResSpecNoUpper()","blParseResSpec()");
841  return(blParseResSpec(spec, chain, resnum, insert));
842 }
843 
844 BOOL DoParseResSpec(char *spec, char *chain, int *resnum, char *insert,
845  BOOL uppercaseresspec)
846 {
847  DEPRECATED("DoParseResSpec()","blDoParseResSpec()");
848  return(blDoParseResSpec(spec, chain, resnum, insert,
849  uppercaseresspec));
850 }
851 
852 BOOL RepSChain(PDB *pdb, char *sequence, char *ChiTable, char *RefCoords)
853 {
854  DEPRECATED("RepSChain()","blRepSChain()");
855  return(blRepSChain(pdb, sequence, ChiTable, RefCoords));
856 }
857 
858 PDB *FindNextChainPDB(PDB *pdb)
859 {
860  DEPRECATED("FindNextChainPDB()","blFindNextChainPDB()");
861  return(blFindNextChainPDB(pdb));
862 }
863 
864 BOOL FixCterPDB(PDB *pdb, int style)
865 {
866  DEPRECATED("FixCterPDB()","blFixCterPDB()");
867  return(blFixCterPDB(pdb, style));
868 }
869 
870 BOOL CalcCterCoords(PDB *p, PDB *ca_p, PDB *c_p, PDB *o_p)
871 {
872  DEPRECATED("CalcCterCoords()","blCalcCterCoords()");
873  return(blCalcCterCoords(p, ca_p, c_p, o_p));
874 }
875 
876 int CalcTetraHCoords(PDB *nter, COOR *coor)
877 {
878  DEPRECATED("CalcTetraHCoords()","blCalcTetraHCoords()");
879  return(blCalcTetraHCoords(nter, coor));
880 }
881 
882 int AddNTerHs(PDB **ppdb, BOOL Charmm)
883 {
884  DEPRECATED("AddNTerHs()","blAddNTerHs()");
885  return(blAddNTerHs(ppdb, Charmm));
886 }
887 
888 char *FNam2PDB(char *filename)
889 {
890  DEPRECATED("FNam2PDB()","blFNam2PDB()");
891  return(blFNam2PDB(filename));
892 }
893 
894 PDB *TermPDB(PDB *pdb, int length)
895 {
896  DEPRECATED("TermPDB()","blTermPDB()");
897  return(blTermPDB(pdb, length));
898 }
899 
900 PDB *FindHetatmResidueSpec(PDB *pdb, char *resspec)
901 {
902  DEPRECATED("FindHetatmResidueSpec()","blFindHetatmResidueSpec()");
903  return(blFindHetatmResidueSpec(pdb, resspec));
904 }
905 
906 PDB *FindResidueSpec(PDB *pdb, char *resspec)
907 {
908  DEPRECATED("FindResidueSpec()","blFindResidueSpec()");
909  return(blFindResidueSpec(pdb, resspec));
910 }
911 
912 PDB *FindNextResidue(PDB *pdb)
913 {
914  DEPRECATED("FindNextResidue()","blFindNextResidue()");
915  return(blFindNextResidue(pdb));
916 }
917 
918 PDB *DupePDB(PDB *in)
919 {
920  DEPRECATED("DupePDB()","blDupePDB()");
921  return(blDupePDB(in));
922 }
923 
924 BOOL CopyPDBCoords(PDB *out, PDB *in)
925 {
926  DEPRECATED("CopyPDBCoords()","blCopyPDBCoords()");
927  return(blCopyPDBCoords(out, in));
928 }
929 
930 void CalcCellTrans(VEC3F UnitCell, VEC3F CellAngles, VEC3F *xtrans,
931  VEC3F *ytrans, VEC3F *ztrans)
932 {
933  DEPRECATED("CalcCellTrans()","blCalcCellTrans()");
934  blCalcCellTrans(UnitCell, CellAngles, xtrans, ytrans, ztrans);
935 }
936 
937 int GetCrystPDB(FILE *fp, VEC3F *UnitCell, VEC3F *CellAngles,
938  char *spacegroup, REAL OrigMatrix[3][4],
939  REAL ScaleMatrix[3][4])
940 {
941  DEPRECATED("GetCrystPDB()","blGetCrystPDB()");
942  return(blGetCrystPDB(fp, UnitCell, CellAngles, spacegroup, OrigMatrix,
943  ScaleMatrix));
944 }
945 
946 void WriteCrystPDB(FILE *fp, VEC3F UnitCell, VEC3F CellAngles,
947  char *spacegroup, REAL OrigMatrix[3][4],
948  REAL ScaleMatrix[3][4])
949 {
950  DEPRECATED("WriteCrystPDB()","blWriteCrystPDB()");
951  blWriteCrystPDB(fp, UnitCell, CellAngles, spacegroup, OrigMatrix,
952  ScaleMatrix);
953 }
954 
955 PDB *ExtractZonePDB(PDB *inpdb, char *chain1, int resnum1, char *insert1,
956  char *chain2, int resnum2, char *insert2)
957 {
958  DEPRECATED("ExtractZonePDB()","blExtractZonePDBAsCopy()");
959  return(blExtractZonePDBAsCopy(inpdb, chain1, resnum1, insert1, chain2,
960  resnum2, insert2));
961 }
962 
963 PDB *ExtractZoneSpecPDB(PDB *inpdb, char *resspec1, char *resspec2)
964 {
965  DEPRECATED("ExtractZoneSpecPDB()","blExtractZoneSpecPDBAsCopy()");
966  return(blExtractZoneSpecPDBAsCopy(inpdb, resspec1, resspec2));
967 }
968 
969 PDB *FindAtomInRes(PDB *pdb, char *atnam)
970 {
971  DEPRECATED("FindAtomInRes()","blFindAtomInRes()");
972  return(blFindAtomInRes(pdb, atnam));
973 }
974 
975 BOOL InPDBZoneSpec(PDB *p, char *resspec1, char *resspec2)
976 {
977  DEPRECATED("InPDBZoneSpec()","blInPDBZoneSpec()");
978  return(blInPDBZoneSpec(p, resspec1, resspec2));
979 }
980 
981 BOOL AtomNameMatch(char *atnam, char *spec, BOOL *ErrorWarn)
982 {
983  DEPRECATED("AtomNameMatch()","blAtomNameMatch()");
984  return(blAtomNameMatch(atnam, spec, ErrorWarn));
985 }
986 
987 BOOL AtomNameRawMatch(char *atnam, char *spec, BOOL *ErrorWarn)
988 {
989  DEPRECATED("AtomNameRawMatch()","blAtomNameRawMatch()");
990  return(blAtomNameRawMatch(atnam, spec, ErrorWarn));
991 }
992 
993 BOOL LegalAtomSpec(char *spec)
994 {
995  DEPRECATED("LegalAtomSpec()","blLegalAtomSpec()");
996  return(blLegalAtomSpec(spec));
997 }
998 
999 BOOL RepOneSChain(PDB *pdb, char *ResSpec, char aa, char *ChiTable,
1000  char *RefCoords)
1001 {
1002  DEPRECATED("RepOneSChain()","blRepOneSChain()");
1003  return(blRepOneSChain(pdb, ResSpec, aa, ChiTable, RefCoords));
1004 }
1005 
1006 void EndRepSChain(void)
1007 {
1008  DEPRECATED("EndRepSChain()","blEndRepSChain()");
1009  blEndRepSChain();
1010 }
1011 
1012 char **ReadSeqresPDB(FILE *fp, int *nchains)
1013 {
1014  DEPRECATED("ReadSeqresPDB()","blReadSeqresPDB()");
1015  return(blReadSeqresPDB(fp, nchains));
1016 }
1017 
1018 PDB *SelectCaPDB(PDB *pdb)
1019 {
1020  DEPRECATED("SelectCaPDB()","blSelectCaPDB()");
1021  return(blSelectCaPDB(pdb));
1022 }
1023 
1024 char *FixAtomName(char *name, REAL occup)
1025 {
1026  DEPRECATED("FixAtomName()","blFixAtomName()");
1027  return(blFixAtomName(name, occup));
1028 }
1029 
1030 void FreeWholePDB(WHOLEPDB *wpdb)
1031 {
1032  DEPRECATED("FreeWholePDB()","blFreeWholePDB()");
1033  blFreeWholePDB(wpdb);
1034 }
1035 
1036 WHOLEPDB *ReadWholePDB(FILE *fpin)
1037 {
1038  DEPRECATED("ReadWholePDB()","blReadWholePDB()");
1039  return(blReadWholePDB(fpin));
1040 }
1041 
1042 WHOLEPDB *ReadWholePDBAtoms(FILE *fpin)
1043 {
1044  DEPRECATED("ReadWholePDBAtoms()","blReadWholePDBAtoms()");
1045  return(blReadWholePDBAtoms(fpin));
1046 }
1047 
1048 BOOL AddCBtoGly(PDB *pdb)
1049 {
1050  DEPRECATED("AddCBtoGly()","blAddCBtoGly()");
1051  return(blAddCBtoGly(pdb));
1052 }
1053 
1054 BOOL AddCBtoAllGly(PDB *pdb)
1055 {
1056  DEPRECATED("AddCBtoAllGly()","blAddCBtoAllGly()");
1057  return(blAddCBtoAllGly(pdb));
1058 }
1059 
1060 PDB *StripGlyCB(PDB *pdb)
1061 {
1062  DEPRECATED("StripGlyCB()","blStripGlyCB()");
1063  return(blStripGlyCB(pdb));
1064 }
1065 
1066 PDB *RemoveAlternates(PDB *pdb)
1067 {
1068  DEPRECATED("RemoveAlternates()","blRemoveAlternates()");
1069  return(blRemoveAlternates(pdb));
1070 }
1071 
1072 PDB *BuildAtomNeighbourPDBList(PDB *pdb, PDB *pRes, REAL NeighbDist)
1073 {
1074  DEPRECATED("BuildAtomNeighbourPDBList()",
1075  "blBuildAtomNeighbourPDBListAsCopy()");
1076  return(blBuildAtomNeighbourPDBListAsCopy(pdb, pRes, NeighbDist));
1077 }
1078 
1079 PDB *FindAtomWildcardInRes(PDB *pdb, char *pattern)
1080 {
1081  DEPRECATED("FindAtomWildcardInRes()","blFindAtomWildcardInRes()");
1082  return(blFindAtomWildcardInRes(pdb, pattern));
1083 }
1084 
1085 PDB *DupeResiduePDB(PDB *in)
1086 {
1087  DEPRECATED("DupeResiduePDB()","blDupeResiduePDB()");
1088  return(blDupeResiduePDB(in));
1089 }
1090 
1091 PDB *StripWatersPDB(PDB *pdbin, int *natom)
1092 {
1093  DEPRECATED("StripWatersPDB()","blStripWatersPDBAsCopy()");
1094  return(blStripWatersPDBAsCopy(pdbin, natom));
1095 }
1096 
1097 PDBSTRUCT *AllocPDBStructure(PDB *pdb)
1098 {
1099  DEPRECATED("AllocPDBStructure()","blAllocPDBStructure()");
1100  return(blAllocPDBStructure(pdb));
1101 }
1102 
1103 PDB *FindNextChain(PDB *pdb)
1104 {
1105  DEPRECATED("FindNextChain()","blFindNextChain()");
1106  return(blFindNextChain(pdb));
1107 }
1108 
1109 void FreePDBStructure(PDBSTRUCT *pdbstruct)
1110 {
1111  DEPRECATED("FreePDBStructure()","blFreePDBStructure()");
1112  blFreePDBStructure(pdbstruct);
1113 }
1114 
1115 void SetElementSymbolFromAtomName(char *element, char *atom_name)
1116 {
1117  DEPRECATED("SetElementSymbolFromAtomName()","blSetElementSymbolFromAtomName()");
1118  blSetElementSymbolFromAtomName(element, atom_name);
1119 }
1120 
1121 
1122 
1123 
1124 
1125 /************************************************************************/
1126 /* Renamed functions: aalist.h */
1127 
1128 AA *InsertNextResiduesInAAList(AA *a, char res, int nres)
1129 {
1130  DEPRECATED("InsertNextResiduesInAAList()","blInsertNextResiduesInAAList()");
1131  return(blInsertNextResiduesInAAList(a, res, nres));
1132 }
1133 
1134 AA *InsertNextResidueInAAList(AA *a, char res)
1135 {
1136  DEPRECATED("InsertNextResidueInAAList()","blInsertNextResidueInAAList()");
1137  return(blInsertNextResidueInAAList(a, res));
1138 }
1139 
1140 char *BuildSeqFromAAList(AA *aa)
1141 {
1142  DEPRECATED("BuildSeqFromAAList()","blBuildSeqFromAAList()");
1143  return(blBuildSeqFromAAList(aa));
1144 }
1145 
1146 AA *InsertResidueInAAListAt(AA *aa, char res, int pos)
1147 {
1148  DEPRECATED("InsertResidueInAAListAt()","blInsertResidueInAAListAt()");
1149  return(blInsertResidueInAAListAt(aa, res, pos));
1150 }
1151 
1152 AA *InsertResiduesInAAListAt(AA *aa, char res, int nres, int pos)
1153 {
1154  DEPRECATED("InsertResiduesInAAListAt()","blInsertResiduesInAAListAt()");
1155  return(blInsertResiduesInAAListAt(aa, res, nres, pos));
1156 }
1157 
1158 AA *BuildAAList(char *seq)
1159 {
1160  DEPRECATED("BuildAAList()","blBuildAAList()");
1161  return(blBuildAAList(seq));
1162 }
1163 
1164 int FindAAListOffsetByResnum(AA *aa, int resnum)
1165 {
1166  DEPRECATED("FindAAListOffsetByResnum()","blFindAAListOffsetByResnum()");
1167  return(blFindAAListOffsetByResnum(aa, resnum));
1168 }
1169 
1170 AA *FindAAListItemByResnum(AA *aa, int resnum)
1171 {
1172  DEPRECATED("FindAAListItemByResnum()","blFindAAListItemByResnum()");
1173  return(blFindAAListItemByResnum(aa, resnum));
1174 }
1175 
1176 void SetAAListFlagByResnum(AA *aa, int resnum)
1177 {
1178  DEPRECATED("SetAAListFlagByResnum()","blSetAAListFlagByResnum()");
1179  blSetAAListFlagByResnum(aa, resnum);
1180 }
1181 
1182 char *BuildFlagSeqFromAAList(AA *aa, char ch)
1183 {
1184  DEPRECATED("BuildFlagSeqFromAAList()","blBuildFlagSeqFromAAList()");
1185  return(blBuildFlagSeqFromAAList(aa, ch));
1186 }
1187 
1188 int GetAAListLen(AA *aa)
1189 {
1190  DEPRECATED("GetAAListLen()","blGetAAListLen()");
1191  return(blGetAAListLen(aa));
1192 }
1193 
1194 
1195 
1196 
1197 /************************************************************************/
1198 /* Renamed functions: cssr.h */
1199 
1200 CSSR *ReadCSSR(FILE *fp, int *natom, char *name, char *title)
1201 {
1202  DEPRECATED("ReadCSSR()","blReadCSSR()");
1203  return(blReadCSSR(fp, natom, name, title));
1204 }
1205 
1206 PDB *ReadCSSRasPDB(FILE *fp, int *natom)
1207 {
1208  DEPRECATED("ReadCSSRasPDB()","blReadCSSRasPDB()");
1209  return(blReadCSSRasPDB(fp, natom));
1210 }
1211 
1212 void NormaliseCSSR(CSSR *cssr, REAL cell[3], REAL alpha, REAL beta, REAL gamma)
1213 {
1214  DEPRECATED("NormaliseCSSR()","blNormaliseCSSR()");
1215  blNormaliseCSSR(cssr, cell, alpha, beta, gamma);
1216 }
1217 
1218 void NormalisePDB(PDB *pdb, REAL cell[3], REAL alpha, REAL beta, REAL gamma)
1219 {
1220  DEPRECATED("NormalisePDB()","blNormalisePDB()");
1221  blNormalisePDB(pdb, cell, alpha, beta, gamma);
1222 }
1223 
1224 void ortho(REAL cell[3], REAL alpha, REAL beta, REAL gamma, REAL amatrx[3][3], int isw, int ncode)
1225 {
1226  DEPRECATED("Ortho()","blOrtho()");
1227  blOrtho(cell, alpha, beta, gamma, amatrx, isw, ncode);
1228 }
1229 
1230 void WriteCSSR(FILE *fp, CSSR *cssr, char *name, char *title)
1231 {
1232  DEPRECATED("WriteCSSR()","blWriteCSSR()");
1233  blWriteCSSR(fp, cssr, name, title);
1234 }
1235 
1236 
1237 
1238 
1239 /************************************************************************/
1240 /* Renamed functions: fit.h */
1241 
1242 BOOL matfit(COOR *x1, COOR *x2, REAL rm[3][3], int n, REAL *wt1, BOOL column)
1243 {
1244  DEPRECATED("matfit()","blMatfit()");
1245  return(blMatfit(x1, x2, rm, n, wt1, column));
1246 }
1247 
1248 
1249 
1250 /************************************************************************/
1251 /* Renamed functions: hbond.h */
1252 
1253 int IsHBonded(PDB *res1, PDB *res2, int type)
1254 {
1255  DEPRECATED("IsHBonded()","blIsHBonded()");
1256  return(blIsHBonded(res1, res2, type));
1257 }
1258 
1259 BOOL ValidHBond(PDB *AtomH, PDB *AtomD, PDB *AtomA, PDB *AtomP)
1260 {
1261  DEPRECATED("ValidHBond()","blValidHBond()");
1262  return(blValidHBond(AtomH, AtomD, AtomA, AtomP));
1263 }
1264 
1265 int IsMCDonorHBonded(PDB *res1, PDB *res2, int type)
1266 {
1267  DEPRECATED("IsMCDonorHBonded()","blIsMCDonorHBonded()");
1268  return(blIsMCDonorHBonded(res1, res2, type));
1269 }
1270 
1271 int IsMCAcceptorHBonded(PDB *res1, PDB *res2, int type)
1272 {
1273  DEPRECATED("IsMCAcceptorHBonded()","blIsMCAcceptorHBonded()");
1274  return(blIsMCAcceptorHBonded(res1, res2, type));
1275 }
1276 
1277 
1278 
1279 
1280 
1281 /************************************************************************/
1282 /* Renamed functions: seq.h */
1283 
1284 char throne(char *three)
1285 {
1286  DEPRECATED("throne()","blThrone()");
1287  return(blThrone(three));
1288 }
1289 
1290 char thronex(char *three)
1291 {
1292  DEPRECATED("thronex()","blThronex()");
1293  return(blThronex(three));
1294 }
1295 
1296 char *onethr(char one)
1297 {
1298  DEPRECATED("onethr()","blOnethr()");
1299  return(blOnethr(one));
1300 }
1301 
1302 char *DoPDB2Seq(PDB *pdb, BOOL DoAsxGlx, BOOL ProtOnly, BOOL NoX)
1303 {
1304  DEPRECATED("DoPDB2Seq()","blDoPDB2Seq()");
1305  return(blDoPDB2Seq(pdb, DoAsxGlx, ProtOnly, NoX));
1306 }
1307 
1308 int SplitSeq(char *LinearSeq, char **seqs)
1309 {
1310  DEPRECATED("SplitSeq()","blSplitSeq()");
1311  return(blSplitSeq(LinearSeq, seqs));
1312 }
1313 
1314 int ReadSimplePIR(FILE *fp, int maxres, char **seqs)
1315 {
1316  DEPRECATED("ReadSimplePIR()","blReadSimplePIR()");
1317  return(blReadSimplePIR(fp, maxres, seqs));
1318 }
1319 
1320 
1321 int ReadPIR(FILE *fp, BOOL DoInsert, char **seqs, int maxchain,
1322  SEQINFO *seqinfo, BOOL *punct, BOOL *error)
1323 {
1324  DEPRECATED("ReadPIR()","blReadPIR()");
1325  return(blReadPIR(fp, DoInsert, seqs, maxchain, seqinfo, punct, error));
1326 }
1327 
1328 int ReadRawPIR(FILE *fp, char **seqs, int maxchain, BOOL upcase,
1329  SEQINFO *seqinfo, BOOL *error)
1330 {
1331  DEPRECATED("ReadRawPIR()","blReadRawPIR()");
1332  return(blReadRawPIR(fp, seqs, maxchain, upcase, seqinfo, error));
1333 }
1334 
1335 int align(char *seq1, int length1, char *seq2, int length2,
1336  BOOL verbose, BOOL identity, int penalty,
1337  char *align1, char *align2, int *align_len)
1338 {
1339  DEPRECATED("align()","blAlign()");
1340  return(blAlign(seq1, length1, seq2, length2,
1341  verbose, identity, penalty,
1342  align1, align2, align_len));
1343 }
1344 
1345 int affinealign(char *seq1, int length1, char *seq2, int length2,
1346  BOOL verbose, BOOL identity, int penalty, int penext,
1347  char *align1, char *align2, int *align_len)
1348 {
1349  DEPRECATED("affinealign()","blAffinealign()");
1350  return(blAffinealign(seq1, length1, seq2, length2,
1351  verbose, identity, penalty, penext,
1352  align1, align2, align_len));
1353 }
1354 
1355 
1356 int CalcMDMScore(char resa, char resb)
1357 {
1358  DEPRECATED("CalcMDMScore()","blCalcMDMScore()");
1359  return(blCalcMDMScore(resa, resb));
1360 }
1361 
1362 int affinealignuc(char *seq1, int length1, char *seq2, int length2,
1363  BOOL verbose, BOOL identity, int penalty, int penext,
1364  char *align1, char *align2, int *align_len)
1365 {
1366  DEPRECATED("affinealignuc()","blAffinealignuc()");
1367  return(blAffinealignuc(seq1, length1, seq2, length2,
1368  verbose, identity, penalty, penext,
1369  align1, align2, align_len));
1370 }
1371 
1372 int CalcMDMScoreUC(char resa, char resb)
1373 {
1374  DEPRECATED("CalcMDMScoreUC()","blCalcMDMScoreUC()");
1375  return(blCalcMDMScoreUC(resa, resb));
1376 }
1377 
1378 BOOL ReadMDM(char *mdmfile)
1379 {
1380  DEPRECATED("ReadMDM()","blReadMDM()");
1381  return(blReadMDM(mdmfile));
1382 }
1383 
1384 int ZeroMDM(void)
1385 {
1386  DEPRECATED("ZeroMDM()","blZeroMDM()");
1387  return(blZeroMDM());
1388 }
1389 
1390 char DNAtoAA(char *dna)
1391 {
1392  DEPRECATED("DNAtoAA()","blDNAtoAA()");
1393  return(blDNAtoAA(dna));
1394 }
1395 
1396 int TrueSeqLen(char *sequence)
1397 {
1398  DEPRECATED("TrueSeqLen()","blTrueSeqLen()");
1399  return(blTrueSeqLen(sequence));
1400 }
1401 
1402 int KnownSeqLen(char *sequence)
1403 {
1404  DEPRECATED("KnownSeqLen()","blKnownSeqLen()");
1405  return(blKnownSeqLen(sequence));
1406 }
1407 
1408 BOOL NumericReadMDM(char *mdmfile)
1409 {
1410  DEPRECATED("NumericReadMDM()","blNumericReadMDM()");
1411  return(blNumericReadMDM(mdmfile));
1412 }
1413 
1414 int NumericCalcMDMScore(int resa, int resb)
1415 {
1416  DEPRECATED("NumericCalcMDMScore()","blNumericCalcMDMScore()");
1417  return(blNumericCalcMDMScore(resa, resb));
1418 }
1419 
1420 int NumericAffineAlign(int *seq1, int length1, int *seq2, int length2,
1421  BOOL verbose, BOOL identity, int penalty,
1422  int penext, int *align1, int *align2,
1423  int *align_len)
1424 {
1425  DEPRECATED("NumericAffineAlign()","blNumericAffineAlign()");
1426  return(blNumericAffineAlign(seq1, length1, seq2, length2,
1427  verbose, identity, penalty,
1428  penext, align1, align2,
1429  align_len));
1430 }
1431 
1432 void SetMDMScoreWeight(char resa, char resb, REAL weight)
1433 {
1434  DEPRECATED("SetMDMScoreWeight()","blSetMDMScoreWeight()");
1435  blSetMDMScoreWeight(resa, resb, weight);
1436 }
1437 
1438 /** \endcond */
1439 /************************************************************************/
PDB * blRemoveAlternates(PDB *pdb)
Definition: ReadPDB.c:1362
PDB ** blIndexPDB(PDB *pdb, int *natom)
Definition: IndexPDB.c:117
int natoms
Definition: pdb.h:377
void blEndRepSChain(void)
Definition: rsc.c:479
PDB * blFindNextChain(PDB *pdb)
Definition: StructurePDB.c:252
Defines for CSSR handling.
PDB * blKillPDB(PDB *pdb, PDB *prev)
Definition: KillPDB.c:214
BOOL blCopyPDBCoords(PDB *out, PDB *in)
void blSetChi(PDB *pdb, PDB *next, REAL chi, int type)
Definition: SetChi.c:119
char ** blReadSeqresPDB(FILE *fp, int *nchains)
Definition: RdSeqPDB.c:113
Include file for PDB routines.
int blCalcMDMScoreUC(char resa, char resb)
Definition: align.c:1293
Header file for hbond determining code.
char blThronex(char *three)
Definition: throne.c:188
short BOOL
Definition: SysDefs.h:64
#define NULL
Definition: array2.c:99
AA * blInsertResidueInAAListAt(AA *aa, char res, int pos)
Definition: aalist.c:261
AA * blInsertNextResidueInAAList(AA *a, char res)
Definition: aalist.c:182
BOOL blFitCaCbPDB(PDB *ref_pdb, PDB *fit_pdb, REAL rm[3][3])
Definition: FitCaCbPDB.c:122
void blSetResnam(PDB *ResStart, PDB *NextRes, char *resnam, int resnum, char *insert, char *chain)
Definition: SetResnam.c:101
Definition: pdb.h:298
BOOL blAtomNameRawMatch(char *atnam, char *spec, BOOL *ErrorWarn)
void blWritePDBRecord(FILE *fp, PDB *pdb)
Definition: WritePDB.c:415
int blNumericAffineAlign(int *seq1, int length1, int *seq2, int length2, BOOL verbose, BOOL identity, int penalty, int penext, int *align1, int *align2, int *align_len)
Definition: NumericAlign.c:412
void blOrtho(REAL cell[3], REAL alpha, REAL beta, REAL gamma, REAL amatrx[3][3], int isw, int ncode)
Definition: ReadCSSR.c:643
PDB * blTermPDB(PDB *pdb, int length)
Definition: TermPDB.c:112
Redirect calls to deprecated functions.
void blWriteCrystPDB(FILE *fp, VEC3F UnitCell, VEC3F CellAngles, char *spacegroup, REAL OrigMatrix[3][4], REAL ScaleMatrix[3][4])
PDB * blSelectAtomsPDBAsCopy(PDB *pdbin, int nsel, char **sel, int *natom)
Definition: SelAtPDB.c:173
char * blOnethr(char one)
Definition: throne.c:223
char atnam[8]
Definition: cssr.h:71
AA * blInsertResiduesInAAListAt(AA *aa, char res, int nres, int pos)
Definition: aalist.c:335
void blCalcCellTrans(VEC3F UnitCell, VEC3F CellAngles, VEC3F *xtrans, VEC3F *ytrans, VEC3F *ztrans)
PDBSTRUCT * blAllocPDBStructure(PDB *pdb)
Definition: StructurePDB.c:109
char * blFNam2PDB(char *filename)
Definition: FNam2PDB.c:123
#define FALSE
Definition: macros.h:223
SECSTRUC * blReadSecPDB(FILE *fp, int *nsec)
Definition: RdSecPDB.c:141
Definition: pdb.h:372
#define NEXT(x)
Definition: macros.h:249
PDB * blStripGlyCB(PDB *pdb)
Definition: GlyCB.c:271
void blFreePDBStructure(PDBSTRUCT *pdbstruct)
Definition: StructurePDB.c:219
void blSetMDMScoreWeight(char resa, char resb, REAL weight)
Definition: align.c:1408
int blZeroMDM(void)
Definition: align.c:1358
BOOL blFitCaPDB(PDB *ref_pdb, PDB *fit_pdb, REAL rm[3][3])
Definition: FitCaPDB.c:117
BOOL blNumericReadMDM(char *mdmfile)
Definition: NumericAlign.c:258
PDB * blDupePDB(PDB *in)
Definition: DupePDB.c:113
Definition: seq.h:90
WHOLEPDB * blReadWholePDBAtoms(FILE *fpin)
Definition: ReadPDB.c:2363
int blGetCrystPDB(FILE *fp, VEC3F *UnitCell, VEC3F *CellAngles, char *spacegroup, REAL OrigMatrix[3][4], REAL ScaleMatrix[3][4])
Definition: GetCrystPDB.c:122
int blIsMCAcceptorHBonded(PDB *res1, PDB *res2, int type)
Definition: hbond.c:717
CSSR * blReadCSSR(FILE *fp, int *natom, char *name, char *title)
Definition: ReadCSSR.c:224
BOOL blCheckFileFormatPDBML(FILE *fp)
Definition: ReadPDB.c:2161
Definition: aalist.h:70
WHOLEPDB * blReadWholePDB(FILE *fpin)
Definition: ReadPDB.c:2328
int blIsHBonded(PDB *res1, PDB *res2, int type)
Definition: hbond.c:173
PDB * blReadPDBAtomsOccRank(FILE *fp, int *natom, int OccRank)
Definition: ReadPDB.c:586
int blKnownSeqLen(char *sequence)
Definition: KnownSeqLen.c:107
void blWriteWholePDBTrailer(FILE *fp, WHOLEPDB *wpdb, int numTer)
Definition: WritePDB.c:1643
Definition: MathType.h:69
PDB * blReadPDBAtoms(FILE *fp, int *natom)
Definition: ReadPDB.c:503
int blGetPDBCoor(PDB *pdb, COOR **coor)
Definition: GetPDBCoor.c:104
char * blDoPDB2Seq(PDB *pdb, BOOL DoAsxGlx, BOOL ProtOnly, BOOL NoX)
Definition: PDB2Seq.c:146
PDB * blExtractZonePDBAsCopy(PDB *inpdb, char *chain1, int resnum1, char *insert1, char *chain2, int resnum2, char *insert2)
void blRotatePDB(PDB *pdb, REAL rm[3][3])
Definition: RotPDB.c:101
PDB * blDupeResiduePDB(PDB *in)
BOOL blRepSChain(PDB *pdb, char *sequence, char *ChiTable, char *RefCoords)
Definition: rsc.c:193
double REAL
Definition: MathType.h:67
void blFreeWholePDB(WHOLEPDB *wpdb)
Definition: ReadPDB.c:2293
AA * blInsertNextResiduesInAAList(AA *a, char res, int nres)
Definition: aalist.c:154
BOOL blDoParseResSpec(char *inSpec, char *chain, int *resnum, char *insert, BOOL uppercaseresspec)
Definition: ParseRes.c:214
BOOL blFormatCheckWritePDB(PDB *pdb)
Definition: WritePDB.c:269
PDB * blReadPDB(FILE *fp, int *natom)
Definition: ReadPDB.c:419
void blWriteWholePDBHeader(FILE *fp, WHOLEPDB *wpdb)
Definition: WritePDB.c:1608
PDB * blReadPDBOccRank(FILE *fp, int *natom, int OccRank)
Definition: ReadPDB.c:545
PDB * blFindAtomWildcardInRes(PDB *pdb, char *pattern)
PDB * pdb
Definition: pdb.h:374
Header file for sequence handling.
int blReadPIR(FILE *fp, BOOL DoInsert, char **seqs, int maxchain, SEQINFO *seqinfo, BOOL *punct, BOOL *error)
Definition: ReadPIR.c:180
BOOL blInPDBZone(PDB *p, char *chain, int resnum1, char *insert1, int resnum2, char *insert2)
Definition: InPDBZone.c:115
int blGetAAListLen(AA *aa)
Definition: aalist.c:527
PDB * blFindResidueSpec(PDB *pdb, char *resspec)
int blIsMCDonorHBonded(PDB *res1, PDB *res2, int type)
Definition: hbond.c:660
int blAffinealignuc(char *seq1, int length1, char *seq2, int length2, BOOL verbose, BOOL identity, int penalty, int penext, char *align1, char *align2, int *align_len)
Definition: align.c:583
BOOL blFitNCaCPDB(PDB *ref_pdb, PDB *fit_pdb, REAL rm[3][3])
Definition: FitNCaCPDB.c:114
int blFindAAListOffsetByResnum(AA *aa, int resnum)
Definition: aalist.c:406
PDB * blReadPDBAll(FILE *fp, int *natom)
Definition: ReadPDB.c:460
Definition: cssr.h:63
REAL blCalcChi(PDB *pdb, int type)
Definition: CalcChiPDB.c:111
BOOL blFindZonePDB(PDB *pdb, int start, char *startinsert, int stop, char *stopinsert, char *chain, int mode, PDB **pdb_start, PDB **pdb_stop)
Definition: FindZonePDB.c:105
BOOL blGetResolPDB(FILE *fp, REAL *resolution, REAL *RFactor, int *StrucType)
Definition: ResolPDB.c:193
PDB * blExtractZoneSpecPDBAsCopy(PDB *pdb, char *firstRes, char *lastRes)
AA * blFindAAListItemByResnum(AA *aa, int resnum)
Definition: aalist.c:441
PDB * blFindHetatmResidue(PDB *pdb, char *chain, int resnum, char *insert)
BOOL blAddCBtoAllGly(PDB *pdb)
Definition: GlyCB.c:239
BOOL blFitPDB(PDB *ref_pdb, PDB *fit_pdb, REAL rm[3][3])
Definition: FitPDB.c:117
BOOL blInPDBZoneSpec(PDB *p, char *resspec1, char *resspec2)
PDB * blStripWatersPDBAsCopy(PDB *pdbin, int *natom)
int blCalcTetraHCoords(PDB *nter, COOR *coor)
AA * blBuildAAList(char *seq)
Definition: aalist.c:359
char * blBuildSeqFromAAList(AA *aa)
Definition: aalist.c:221
BOOL blWritePDBAsPDBML(FILE *fp, PDB *pdb)
Definition: WritePDB.c:525
BOOL blMatfit(COOR *x1, COOR *x2, REAL rm[3][3], int n, REAL *wt1, BOOL column)
Definition: fit.c:128
int blHAddPDB(FILE *fp, PDB *pdb)
Definition: HAddPDB.c:250
PDB * blShuffleBB(PDB *pdb)
Definition: OrderPDB.c:389
void blWritePDBRecordAtnam(FILE *fp, PDB *pdb)
Definition: WritePDB.c:471
BOOL blKillSidechain(PDB *ResStart, PDB *NextRes, BOOL doCB)
BOOL blGetExptlOld(FILE *fp, REAL *resolution, REAL *RFactor, REAL *FreeR, int *StrucType)
Definition: ResolPDB.c:666
Include file for least squares fitting.
BOOL blReadMDM(char *mdmfile)
Definition: align.c:871
BOOL blGetExptlPDB(FILE *fp, REAL *resolution, REAL *RFactor, REAL *FreeR, int *StrucType)
Definition: ResolPDB.c:289
BOOL blMovePDB(PDB *move, PDB **from, PDB **to)
Definition: MovePDB.c:100
void blWriteGromosPDB(FILE *fp, PDB *pdb)
Definition: WritePDB.c:1491
int blWritePDB(FILE *fp, PDB *pdb)
Definition: WritePDB.c:223
PDB * blFindNextChainPDB(PDB *pdb)
int blAddNTerHs(PDB **ppdb, BOOL Charmm)
Definition: AddNTerHs.c:123
char blThrone(char *three)
Definition: throne.c:153
BOOL blAddCBtoGly(PDB *pdb)
Definition: GlyCB.c:112
void blCopyPDB(PDB *out, PDB *in)
Definition: CopyPDB.c:108
void blGetCofGPDBRange(PDB *start, PDB *stop, VEC3F *cg)
int blSplitSeq(char *LinearSeq, char **seqs)
Definition: SplitSeq.c:115
int blTrueSeqLen(char *sequence)
Definition: TrueSeqLen.c:106
PDB * blAppendPDB(PDB *first, PDB *second)
Definition: AppendPDB.c:109
Include file for amino acid linked lists.
void blWriteCSSR(FILE *fp, CSSR *cssr, char *name, char *title)
Definition: WrtCSSR.c:130
Definition: pdb.h:349
PDB * blGetPDBByN(PDB *pdb, int n)
Definition: GetPDBByN.c:106
void blWriteGromosPDBRecord(FILE *fp, PDB *pdb)
Definition: WritePDB.c:1517
DISULPHIDE * blReadDisulphidesPDB(FILE *fp, BOOL *error)
Definition: RdSSPDB.c:114
PDB * blShuffleResPDB(PDB *start, PDB *end, BOOL Pad)
Definition: OrderPDB.c:228
struct cssr_entry * next
Definition: cssr.h:67
int blAlign(char *seq1, int length1, char *seq2, int length2, BOOL verbose, BOOL identity, int penalty, char *align1, char *align2, int *align_len)
Definition: align.c:214
PDB * blFindResidue(PDB *pdb, char *chain, int resnum, char *insert)
Definition: FindResidue.c:117
char blDNAtoAA(char *dna)
Definition: DNAtoAA.c:110
FILE * blOpenPGPFile(char *pgpfile, BOOL AllHyd)
Definition: HAddPDB.c:1347
char * blFixAtomName(char *name, REAL occup)
Definition: ReadPDB.c:1291
void blGetCofGPDB(PDB *pdb, VEC3F *cg)
Definition: GetCGPDB.c:98
void blGetCofGPDBSCRange(PDB *start, PDB *stop, VEC3F *cg)
int blReadRawPIR(FILE *fp, char **seqs, int maxchain, BOOL upcase, SEQINFO *seqinfo, BOOL *error)
Definition: ReadRawPIR.c:169
int blWritePDBAsPDBorGromos(FILE *fp, PDB *pdb, BOOL doGromos)
Definition: WritePDB.c:308
char * blBuildFlagSeqFromAAList(AA *aa, char ch)
Definition: aalist.c:494
PDB * blFindNextResidue(PDB *pdb)
int blCalcMDMScore(char resa, char resb)
Definition: align.c:1220
char * blReportStructureType(int type)
Definition: ResolPDB.c:410
BOOL blRepOneSChain(PDB *pdb, char *ResSpec, char aa, char *ChiTable, char *RefCoords)
Definition: rsc.c:319
PDB * blStripHPDBAsCopy(PDB *pdbin, int *natom)
Definition: StripHPDB.c:115
void blSetAAListFlagByResnum(AA *aa, int resnum)
Definition: aalist.c:470
void blOriginPDB(PDB *pdb)
Definition: OriginPDB.c:96
BOOL blFixCterPDB(PDB *pdb, int style)
Definition: FixCterPDB.c:138
int blNumericCalcMDMScore(int resa, int resb)
Definition: NumericAlign.c:342
PDB * blFindAtomInRes(PDB *pdb, char *atnam_in)
WHOLEPDB * blDoReadPDBML(FILE *fp, BOOL AllAtoms, int OccRank, int ModelNum, BOOL DoWhole)
Definition: ReadPDB.c:1624
PDB * blReadCSSRasPDB(FILE *fp, int *natom)
Definition: ReadCSSR.c:368
PDB * blFindHetatmResidueSpec(PDB *pdb, char *resspec)
void blNormalisePDB(PDB *pdb, REAL cell[3], REAL alpha, REAL beta, REAL gamma)
Definition: ReadCSSR.c:574
void blNormaliseCSSR(CSSR *cssr, REAL cell[3], REAL alpha, REAL beta, REAL gamma)
Definition: ReadCSSR.c:513
int blReadSimplePIR(FILE *fp, int maxres, char **seqs)
BOOL blAtomNameMatch(char *atnam, char *spec, BOOL *ErrorWarn)
int blReadPGP(FILE *fp)
Definition: HAddPDB.c:301
PDB * blBuildAtomNeighbourPDBListAsCopy(PDB *pdb, PDB *pRes, REAL NeighbDist)
BOOL blGetAtomTypes(char *resnam, char **AtomTypes)
Definition: OrderPDB.c:349
PDB * blSelectCaPDB(PDB *pdb)
Definition: SelectCaPDB.c:124
int blAffinealign(char *seq1, int length1, char *seq2, int length2, BOOL verbose, BOOL identity, int penalty, int penext, char *align1, char *align2, int *align_len)
Definition: align.c:275
char chain[blMAXCHAINLABEL]
Definition: pdb.h:321
void blTranslatePDB(PDB *pdb, VEC3F tvect)
Definition: TranslatePDB.c:95
BOOL blCalcCterCoords(PDB *p, PDB *ca_p, PDB *c_p, PDB *o_p)
void blSetElementSymbolFromAtomName(char *element, char *atom_name)
Definition: WritePDB.c:1433
WHOLEPDB * blDoReadPDB(FILE *fp, BOOL AllAtoms, int OccRank, int ModelNum, BOOL DoWhole)
Definition: ReadPDB.c:707
BOOL blParseResSpec(char *spec, char *chain, int *resnum, char *insert)
Definition: ParseRes.c:158
PDB * blFixOrderPDB(PDB *pdb, BOOL Pad, BOOL Renum)
Definition: OrderPDB.c:169
REAL blCalcRMSPDB(PDB *pdb1, PDB *pdb2)
Definition: CalcRMSPDB.c:110
Definition: pdb.h:360
#define DEPRECATED(s, t)
Definition: deprecated.h:167
BOOL blValidHBond(PDB *AtomH, PDB *AtomD, PDB *AtomA, PDB *AtomP)
Definition: hbond.c:303
void blRenumAtomsPDB(PDB *pdb, int offset)
void blApplyMatrixPDB(PDB *pdb, REAL matrix[3][3])
Definition: ApMatPDB.c:92