IMP logo
IMP Reference Guide  2.6.2
The Integrative Modeling Platform
pdb.h
Go to the documentation of this file.
1 /**
2  * \file IMP/atom/pdb.h
3  * \brief Functions to read PDBs
4  *
5  * Copyright 2007-2016 IMP Inventors. All rights reserved.
6  *
7  */
8 
9 #ifndef IMPATOM_PDB_H
10 #define IMPATOM_PDB_H
11 
12 #include <IMP/atom/atom_config.h>
13 #include "Hierarchy.h"
14 #include "Atom.h"
15 #include "element.h"
16 #include "internal/pdb.h"
17 #include "atom_macros.h"
18 #include <IMP/file.h>
19 #include "Selection.h"
20 #include <IMP/Model.h>
21 #include <IMP/Particle.h>
22 #include <IMP/OptimizerState.h>
23 #include <IMP/internal/utility.h>
24 #include <boost/format.hpp>
25 #include <boost/algorithm/string.hpp>
26 
27 IMPATOM_BEGIN_NAMESPACE
28 
29 //! Select which atoms to read from a PDB file
30 /** Selector is a general purpose class used to select records from a PDB
31  file. Using descendants of this class one may implement arbitrary
32  selection functions with operator() and pass them to PDB reading functions
33  for object selection. Simple selectors can be used to build more complicated
34  ones. Inheritance means "AND" unless otherwise noted (that is, the
35  CAlphaPDBSelector takes all non-alternate C-alphas since it inherits from
36  NonAlternativePDBSelector).
37 
38  \see read_pdb
39 */
40 class IMPATOMEXPORT PDBSelector : public IMP::Object {
41  public:
42  PDBSelector(std::string name) : Object(name) {}
43  //! Return true if the line should be processed
44  virtual bool get_is_selected(const std::string &pdb_line) const = 0;
45  virtual ~PDBSelector();
46 };
47 
49 
50 //! Select all ATOM and HETATM records which are not alternatives
52  public:
53  NonAlternativePDBSelector(std::string name = "NonAlternativePDBSelector%1%")
54  : PDBSelector(name) {}
55 
56  bool get_is_selected(const std::string &pdb_line) const {
57  return (internal::atom_alt_loc_indicator(pdb_line) == ' ' ||
58  internal::atom_alt_loc_indicator(pdb_line) == 'A');
59  }
61 };
62 
63 //! Select all non-alternative ATOM records
65  public:
66  ATOMPDBSelector(std::string name = "ATOMPDBSelector%1%")
67  : NonAlternativePDBSelector(name) {}
68 
69  bool get_is_selected(const std::string &pdb_line) const {
70  return (NonAlternativePDBSelector::get_is_selected(pdb_line) &&
71  internal::is_ATOM_rec(pdb_line));
72  }
74 };
75 
76 //! Select all CA ATOM records
78  public:
79  CAlphaPDBSelector(std::string name = "CAlphaPDBSelector%1%")
80  : NonAlternativePDBSelector(name) {}
81 
82  bool get_is_selected(const std::string &pdb_line) const {
83  if (!NonAlternativePDBSelector::get_is_selected(pdb_line)) return false;
84  const std::string type = internal::atom_type(pdb_line);
85  return (type[1] == 'C' && type[2] == 'A' && type[3] == ' ');
86  }
88 };
89 
90 //! Select all CB ATOM records
92  public:
93  CBetaPDBSelector(std::string name = "CBetaPDBSelector%1%")
94  : NonAlternativePDBSelector(name) {}
95 
96  bool get_is_selected(const std::string &pdb_line) const {
97  if (!NonAlternativePDBSelector::get_is_selected(pdb_line)) return false;
98  const std::string type = internal::atom_type(pdb_line);
99  return (type[1] == 'C' && type[2] == 'B' && type[3] == ' ');
100  }
102 };
103 
104 //! Select all atoms of the given types
105 /** Note that unlike CAlphaPDBSelector and similar classes, this selects all
106  atoms, even those in alternative locations (combine with
107  a NonAlternativePDBSelector if necessary).
108  */
110  Strings atom_types_;
111  public:
112  AtomTypePDBSelector(Strings atom_types,
113  std::string name = "AtomTypePDBSelector%1%")
114  : PDBSelector(name), atom_types_(atom_types) {
115  std::sort(atom_types_.begin(), atom_types_.end());
116  }
117 
118  bool get_is_selected(const std::string &pdb_line) const {
119  std::string type = internal::atom_type(pdb_line);
120  boost::trim(type);
121  return std::binary_search(atom_types_.begin(), atom_types_.end(), type);
122  }
124 };
125 
126 //! Select all atoms in residues of the given types
127 /** Note that unlike CAlphaPDBSelector and similar classes, this selects all
128  atoms, even those in alternative locations (combine with
129  a NonAlternativePDBSelector if necessary).
130  */
132  Strings residue_types_;
133  public:
134  ResidueTypePDBSelector(Strings residue_types,
135  std::string name = "ResidueTypePDBSelector%1%")
136  : PDBSelector(name), residue_types_(residue_types) {
137  std::sort(residue_types_.begin(), residue_types_.end());
138  }
139 
140  bool get_is_selected(const std::string &pdb_line) const {
141  std::string type = internal::atom_residue_name(pdb_line);
142  boost::trim(type);
143  return std::binary_search(residue_types_.begin(), residue_types_.end(),
144  type);
145  }
147 };
148 
149 //! Select all C (not CA or CB) ATOM records
151  public:
152  CPDBSelector(std::string name = "CPDBSelector%1%")
153  : NonAlternativePDBSelector(name) {}
154 
155  bool get_is_selected(const std::string &pdb_line) const {
156  if (!NonAlternativePDBSelector::get_is_selected(pdb_line)) return false;
157  const std::string type = internal::atom_type(pdb_line);
158  return (type[1] == 'C' && type[2] == ' ' && type[3] == ' ');
159  }
161 };
162 
163 //! Select all N ATOM records
165  public:
166  NPDBSelector(std::string name = "NPDBSelector%1%")
167  : NonAlternativePDBSelector(name) {}
168 
169  bool get_is_selected(const std::string &pdb_line) const {
170  if (!NonAlternativePDBSelector::get_is_selected(pdb_line)) return false;
171  const std::string type = internal::atom_type(pdb_line);
172  return (type[1] == 'N' && type[2] == ' ' && type[3] == ' ');
173  }
175 };
176 
177 //! Defines a selector that will pick every ATOM and HETATM record
178 class AllPDBSelector : public PDBSelector {
179  public:
180  AllPDBSelector(std::string name = "AllPDBSelector%1%") : PDBSelector(name) {}
181 
182  bool get_is_selected(const std::string &pdb_line) const {
183  return (true || pdb_line.empty());
184  }
186 };
187 
188 //! Select all ATOM and HETATM records with the given chain ids
190  public:
191  bool get_is_selected(const std::string &pdb_line) const {
192  if (!NonAlternativePDBSelector::get_is_selected(pdb_line)) {
193  return false;
194  }
195  for (int i = 0; i < (int)chains_.length(); i++) {
196  if (internal::atom_chain_id(pdb_line) == chains_[i]) return true;
197  }
198  return false;
199  }
201  //! The chain id can be any character in chains
202  ChainPDBSelector(const std::string &chains,
203  std::string name = "ChainPDBSelector%1%")
204  : NonAlternativePDBSelector(name), chains_(chains) {}
205 
206  private:
207  std::string chains_;
208 };
209 
210 //! Select all non-water ATOM and HETATM records
212  public:
213  WaterPDBSelector(std::string name = "WaterPDBSelector%1%")
214  : NonAlternativePDBSelector(name) {}
215 
216  bool get_is_selected(const std::string &pdb_line) const {
217  if (!NonAlternativePDBSelector::get_is_selected(pdb_line)) {
218  return false;
219  }
220  const std::string res_name = internal::atom_residue_name(pdb_line);
221  return ((res_name[0] == 'H' && res_name[1] == 'O' && res_name[2] == 'H') ||
222  (res_name[0] == 'D' && res_name[1] == 'O' && res_name[2] == 'D'));
223  }
225 };
226 
227 //! Select all hydrogen ATOM and HETATM records
228 class IMPATOMEXPORT HydrogenPDBSelector : public NonAlternativePDBSelector {
229  bool is_hydrogen(std::string pdb_line) const;
230 
231  public:
232  HydrogenPDBSelector(std::string name = "HydrogenPDBSelector%1%")
233  : NonAlternativePDBSelector(name) {}
234 
235  bool get_is_selected(const std::string &pdb_line) const {
236  if (!NonAlternativePDBSelector::get_is_selected(pdb_line)) return false;
237  return is_hydrogen(pdb_line);
238  }
240 };
241 
242 //! Select non water and non hydrogen atoms
245 
246  public:
247  bool get_is_selected(const std::string &pdb_line) const {
248  if (!NonAlternativePDBSelector::get_is_selected(pdb_line)) {
249  return false;
250  }
251  return (!ws_->get_is_selected(pdb_line) && !hs_->get_is_selected(pdb_line));
252  }
254  NonWaterNonHydrogenPDBSelector(std::string name)
256  ws_(new WaterPDBSelector()),
257  hs_(new HydrogenPDBSelector()) {}
259  : NonAlternativePDBSelector("NonWaterPDBSelector%1%"),
260  ws_(new WaterPDBSelector()),
261  hs_(new HydrogenPDBSelector()) {}
262 };
263 
264 //! Select all non-water non-alternative ATOM and HETATM records
267 
268  public:
269  bool get_is_selected(const std::string &pdb_line) const {
270  if (!NonAlternativePDBSelector::get_is_selected(pdb_line)) {
271  return false;
272  }
273  return (!ws_->get_is_selected(pdb_line));
274  }
276  NonWaterPDBSelector(std::string name)
277  : NonAlternativePDBSelector(name), ws_(new WaterPDBSelector()) {}
279  : NonAlternativePDBSelector("NonWaterPDBSelector%1%"),
280  ws_(new WaterPDBSelector()) {}
281 };
282 
283 //! Select all backbone (N,CA,C,O) ATOM records
285  public:
286  BackbonePDBSelector(std::string name = "BackbonePDBSelector%1%")
288 
289  bool get_is_selected(const std::string &pdb_line) const {
290  if (!NonWaterNonHydrogenPDBSelector::get_is_selected(pdb_line))
291  return false;
292  const std::string type = internal::atom_type(pdb_line);
293  return ((type[1] == 'N' && type[2] == ' ' && type[3] == ' ') ||
294  (type[1] == 'C' && type[2] == 'A' && type[3] == ' ') ||
295  (type[1] == 'C' && type[2] == ' ' && type[3] == ' ') ||
296  (type[1] == 'O' && type[2] == ' ' && type[3] == ' '));
297  }
299 };
300 
301 //! Select all P (= phosphate) ATOM records
303  public:
304  PPDBSelector(std::string name = "PPDBSelector%1%")
305  : NonAlternativePDBSelector(name) {}
306 
307  bool get_is_selected(const std::string &pdb_line) const {
308  if (!NonAlternativePDBSelector::get_is_selected(pdb_line)) return false;
309  const std::string type = internal::atom_type(pdb_line);
310  return (type[1] == 'P' && type[2] == ' ' && type[3] == ' ');
311  }
313 };
314 
315 //! Select atoms which are selected by both selectors
316 /** To use do something like
317  \code
318  read_pdb(name, m, AndPDBSelector(PPDBSelector(), WaterPDBSelector()));
319  \endcode
320 
321  In Python, the and operator (&) can be used to the same effect:
322  \code
323  read_pdb(name, m, PPDBSelector() & WaterPDBSelector());
324  \endcode
325  */
326 class AndPDBSelector : public PDBSelector {
327  const IMP::PointerMember<PDBSelector> a_, b_;
328 
329  public:
330  bool get_is_selected(const std::string &pdb_line) const {
331  return a_->get_is_selected(pdb_line) && b_->get_is_selected(pdb_line);
332  }
335  : PDBSelector("AndPDBSelector%1%"), a_(a), b_(b) {}
336 };
337 
338 //! Select atoms which are selected by either or both selectors
339 /** To use do something like
340  \code
341  read_pdb(name, m, OrPDBSelector(PPDBSelector(), WaterPDBSelector()));
342  \endcode
343 
344  In Python, the or operator (|) can be used to the same effect:
345  \code
346  read_pdb(name, m, PPDBSelector() | WaterPDBSelector());
347  \endcode
348  */
349 class OrPDBSelector : public PDBSelector {
350  const IMP::PointerMember<PDBSelector> a_, b_;
351 
352  public:
353  bool get_is_selected(const std::string &pdb_line) const {
354  return a_->get_is_selected(pdb_line) || b_->get_is_selected(pdb_line);
355  }
358  : PDBSelector("OrPDBSelector%1%"), a_(a), b_(b) {}
359 };
360 
361 //! Select atoms which are selected by either selector but not both
362 /** To use do something like
363  \code
364  read_pdb(name, m, XorPDBSelector(HydrogenPDBSelector(),
365  WaterPDBSelector()));
366  \endcode
367 
368  In Python, the xor operator (^) can be used to the same effect:
369  \code
370  read_pdb(name, m, HydrogenPDBSelector() ^ WaterPDBSelector());
371  \endcode
372  */
373 class XorPDBSelector : public PDBSelector {
374  const IMP::PointerMember<PDBSelector> a_, b_;
375 
376  public:
377  bool get_is_selected(const std::string &pdb_line) const {
378  return a_->get_is_selected(pdb_line) != b_->get_is_selected(pdb_line);
379  }
382  : PDBSelector("XorPDBSelector%1%"), a_(a), b_(b) {}
383 };
384 
385 //! Select atoms which are not selected by a given selector
386 /** To use do something like
387  \code
388  read_pdb(name, m, NotPDBSelector(PPDBSelector()));
389  \endcode
390 
391  In Python, the inversion operator (~) can be used to the same effect:
392  \code
393  read_pdb(name, m, ~PPDBSelector());
394  \endcode
395  */
396 class NotPDBSelector : public PDBSelector {
398 
399  public:
400  bool get_is_selected(const std::string &pdb_line) const {
401  return !a_->get_is_selected(pdb_line);
402  }
404  NotPDBSelector(PDBSelector *a) : PDBSelector("NotPDBSelector%1%"), a_(a) {}
405 };
406 
407 /** @name PDB Reading
408  \anchor pdb_in
409  The read PDB methods produce a hierarchy that looks as follows:
410  - One Atom per ATOM or HETATM record in the PDB.
411  - All Atom particles have a parent which is a Residue.
412  - All Residue particles have a parent which is a Chain.
413 
414  Waters are currently dropped if they are ATOM records. This can be fixed.
415 
416  The read_pdb() functions should successfully parse all valid PDB files. It
417  can produce warnings on files which are not valid. It will attempt to read
418  such files, but all bets are off.
419 
420  When reading PDBs, PDBSelector objects can be used to choose to only process
421  certain record types. See the class documentation for more information.
422  When no PDB selector is supplied for reading, the
423  NonWaterPDBSelector is used.
424 
425  Set the IMP::LogLevel to VERBOSE to see details of parse errors.
426 */
427 //!@{
428 
429 inline PDBSelector *get_default_pdb_selector() {
430  return new NonWaterPDBSelector();
431 }
432 
433 /** Read a all the molecules in the first model of the
434  PDB file.
435  */
436 IMPATOMEXPORT Hierarchy
437  read_pdb(TextInput input, Model *model,
438  PDBSelector *selector = get_default_pdb_selector(),
439  bool select_first_model = true
440 #ifndef IMP_DOXYGEN
441  ,
442  bool no_radii = false
443 #endif
444  );
445 
446 /** Rewrite the coordinates of the passed hierarchy based
447  on the contents of the first model in the PDB file.
448 
449  The hierarchy must have been created by reading from a PDB
450  file and the atom numbers must correspond between the files.
451  These are not really checked.
452 
453  A ValueException is thrown if there are insufficient models
454  in the file.
455 
456  core::RigidMember particles are handled by updating the
457  core::RigidBody algebra::ReferenceFrame3D to align with the
458  loaded particles. Bad things will happen if the loaded coordinates
459  are not a rigid transform of the prior coordinates.
460  */
461 IMPATOMEXPORT void read_pdb(TextInput input, int model, Hierarchy h);
462 
463 /** Read all models from the PDB file.
464  */
465 IMPATOMEXPORT Hierarchies
466  read_multimodel_pdb(TextInput input, Model *model,
467  PDBSelector *selector = get_default_pdb_selector()
468 #ifndef IMP_DOXYGEN
469  ,
470  bool noradii = false
471 #endif
472  );
473 
474 /** @name PDB Writing
475  \anchor pdb_out
476  The methods to write a PDB expects a Hierarchy that looks as follows:
477  - all leaves are Atom particles
478  - all Atom particles have Residue particles as parents
479 
480  All Residue particles that have a Chain particle as an ancestor
481  are considered part of a protein, DNA or RNA, ones without are
482  considered heterogens.
483 
484  The functions produce files that are not valid PDB files,
485  eg only ATOM/HETATM lines are printed for all Atom particles
486  in the hierarchy. Complain if your favorite program can't read them and
487  we might fix it.
488 */
489 //!@{
490 
491 /** Write some atoms to a PDB.
492 */
493 IMPATOMEXPORT void write_pdb(const Selection &mhd, TextOutput out,
494  unsigned int model = 1);
495 
496 /** \brief Write a hierarchy to a PDB as C_alpha atoms.
497 
498  This method is used to write a non-atomic hierarchy into a PDB in a way
499  that can be read by most programs. If the leaves are Residue particles
500  then the index and residue type will be read from them. Otherwise default
501  values will be used so that each leaf ends up in a separate residue.
502 */
503 IMPATOMEXPORT void write_pdb_of_c_alphas(const Selection &mhd,
504  TextOutput out,
505  unsigned int model = 1);
506 
507 /** Write the hierarchies one per frame.
508 */
509 IMPATOMEXPORT void write_multimodel_pdb(const Hierarchies &mhd,
510  TextOutput out);
511 /** @} */
512 
513 #ifndef IMP_DOXYGEN
514 
515 /**
516  This function returns a string in PDB ATOM format
517 */
518 IMPATOMEXPORT std::string get_pdb_string(
519  const algebra::Vector3D &v, int index = -1, AtomType at = AT_CA,
520  ResidueType rt = atom::ALA, char chain = ' ', int res_index = 1,
521  char res_icode = ' ', double occpancy = 1.00, double tempFactor = 0.00,
522  Element e = C);
523 
524 /**
525  This function returns a connectivity string in PDB format
526  \note The CONECT records specify connectivity between atoms for which
527  coordinates are supplied. The connectivity is described using
528  the atom serial number as found in the entry.
529  \note http://www.bmsc.washington.edu/CrystaLinks/man/pdb/guide2.2_frame.html
530 */
531 IMPATOMEXPORT std::string get_pdb_conect_record_string(int, int);
532 #endif
533 
534 /** \class WritePDBOptimizerState
535  This writes a PDB file at the specified interval during optimization.
536  If the file name contains %1% then a new file is written each time
537  with the %1% replaced by the index. Otherwise a new model is written
538  each time to the same file.
539 */
540 class IMPATOMEXPORT WritePDBOptimizerState : public OptimizerState {
541  std::string filename_;
542  ParticleIndexes pis_;
543 
544  public:
546  const ParticleIndexesAdaptor &pis,
547  std::string filename);
548  WritePDBOptimizerState(const atom::Hierarchies mh, std::string filename);
549 
550  protected:
551  virtual void do_update(unsigned int call) IMP_OVERRIDE;
554 };
555 
556 IMPATOM_END_NAMESPACE
557 
558 #endif /* IMPATOM_PDB_H */
Select non water and non hydrogen atoms.
Definition: pdb.h:243
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:400
ChainPDBSelector(const std::string &chains, std::string name="ChainPDBSelector%1%")
The chain id can be any character in chains.
Definition: pdb.h:202
Define the elements used in IMP.
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:56
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:216
Select all backbone (N,CA,C,O) ATOM records.
Definition: pdb.h:284
Select all non-water ATOM and HETATM records.
Definition: pdb.h:211
Select all P (= phosphate) ATOM records.
Definition: pdb.h:302
const AtomType AT_CA
Select atoms which are selected by both selectors.
Definition: pdb.h:326
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:307
#define IMP_OBJECT_METHODS(Name)
Define the basic things needed by any Object.
Definition: object_macros.h:25
Simple atom decorator.
Storage of a model, its restraints, constraints and particles.
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:118
Select all N ATOM records.
Definition: pdb.h:164
void write_pdb(const Selection &mhd, TextOutput out, unsigned int model=1)
virtual ModelObjectsTemp do_get_inputs() const
Handling of file input/output.
virtual void do_update(unsigned int)
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:169
Select all atoms in residues of the given types.
Definition: pdb.h:131
void read_pdb(TextInput input, int model, Hierarchy h)
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:377
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:69
Select all C (not CA or CB) ATOM records.
Definition: pdb.h:150
Class for storing model, its restraints, constraints, and particles.
Definition: Model.h:72
void write_pdb_of_c_alphas(const Selection &mhd, TextOutput out, unsigned int model=1)
Write a hierarchy to a PDB as C_alpha atoms.
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:191
Decorator for helping deal with a hierarchy of molecules.
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:82
Select all CB ATOM records.
Definition: pdb.h:91
Select all ATOM and HETATM records which are not alternatives.
Definition: pdb.h:51
Select all non-alternative ATOM records.
Definition: pdb.h:64
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:155
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:330
Common base class for heavy weight IMP objects.
Definition: Object.h:106
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:96
A smart pointer to a ref-counted Object that is a class member.
Definition: Pointer.h:146
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:140
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:269
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:247
Select all atoms of the given types.
Definition: pdb.h:109
Classes to handle individual model particles. (Note that implementation of inline functions is in int...
#define IMP_OBJECTS(Name, PluralName)
Define the types for storing lists of object pointers.
Definition: object_macros.h:44
Defines a selector that will pick every ATOM and HETATM record.
Definition: pdb.h:178
Various important macros for implementing decorators.
Select atoms which are not selected by a given selector.
Definition: pdb.h:396
Hierarchies read_multimodel_pdb(TextInput input, Model *model, PDBSelector *selector=get_default_pdb_selector())
Object(std::string name)
Construct an object with the given name.
VectorD< 3 > Vector3D
Definition: VectorD.h:395
Shared optimizer state that is invoked upon commitment of new coordinates.
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:182
Select all non-water non-alternative ATOM and HETATM records.
Definition: pdb.h:265
Select atoms which are selected by either or both selectors.
Definition: pdb.h:349
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:289
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:353
Shared optimizer state.
void write_multimodel_pdb(const Hierarchies &mhd, TextOutput out)
bool get_is_selected(const std::string &pdb_line) const
Return true if the line should be processed.
Definition: pdb.h:235
Select all hydrogen ATOM and HETATM records.
Definition: pdb.h:228
Select all CA ATOM records.
Definition: pdb.h:77
Element
The various elements currently supported/known.
Definition: element.h:23
Select which atoms to read from a PDB file.
Definition: pdb.h:40
Select a subset of a hierarchy.
Select atoms which are selected by either selector but not both.
Definition: pdb.h:373
Select all ATOM and HETATM records with the given chain ids.
Definition: pdb.h:189
#define IMP_OVERRIDE
Cause a compile error if this method does not override a parent method.