librdkit-dev 201603.5-2 / usr / include / rdkit / GraphMol / Conformer.h

This file is indexed.

/usr/include/rdkit/GraphMol/Conformer.h is in librdkit-dev 201603.5-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
//
//  Copyright (C) 2001-2008 Greg Landrum and Rational Discovery LLC
//
//   @@ All Rights Reserved @@
//  This file is part of the RDKit.
//  The contents are covered by the terms of the BSD license
//  which is included in the file license.txt, found at the root
//  of the RDKit source tree.
//
#ifndef _RD_CONFORMER_H
#define _RD_CONFORMER_H

#include <Geometry/point.h>
#include <RDGeneral/types.h>
#include <boost/smart_ptr.hpp>

namespace RDKit {
class ROMol;

//! used to indicate errors from incorrect confomer access
class ConformerException : public std::exception {
 public:
  //! construct with an error message
  ConformerException(const char *msg) : _msg(msg){};
  //! construct with an error message
  ConformerException(const std::string &msg) : _msg(msg){};
  //! get the error message
  const char *message() const { return _msg.c_str(); };
  ~ConformerException() throw(){};

 private:
  std::string _msg;
};

//! The class for representing 2D or 3D conformation of a molecule
/*!
  This class contains
  - a pointer to the owing molecule
  - a vector of 3D points (positions of atoms)
*/
class Conformer {
 public:
  friend class ROMol;

  //! Constructor
  Conformer() : df_is3D(true), d_id(0), dp_mol(NULL) { d_positions.clear(); };

  //! Constructor with number of atoms specified ID specification
  Conformer(unsigned int numAtoms) : df_is3D(true), d_id(0), dp_mol(NULL) {
    if (numAtoms) {
      d_positions.resize(numAtoms, RDGeom::Point3D(0.0, 0.0, 0.0));
    } else {
      d_positions.resize(0);
      d_positions.clear();
    }
  };

  //! Copy Constructor: initialize from a second conformation.
  Conformer(const Conformer &other);

  //! Destructor
  ~Conformer(){};

  //! Resize the conformer so that more atoms location can be added.
  //! Useful, for e.g., when adding hydrogens
  void resize(unsigned int size) { d_positions.resize(size); }

  //! Reserve more space for atom position
  void reserve(unsigned int size) { d_positions.reserve(size); }

  //! Get the molecule that oqns this conformation
  ROMol &getOwningMol() const { return *dp_mol; }

  //! Get a const reference to the vector of atom positions
  const RDGeom::POINT3D_VECT &getPositions() const;

  //! Get a reference to the atom positions
  RDGeom::POINT3D_VECT &getPositions();

  //! Get the position of the specified atom
  const RDGeom::Point3D &getAtomPos(unsigned int atomId) const;
  //! overload
  template<class U>
  const RDGeom::Point3D &getAtomPos(U atomId) const {
      return getAtomPos(rdcast<unsigned int>(atomId));
  }

  //! Get the position of the specified atom
  RDGeom::Point3D &getAtomPos(unsigned int atomId);
  //! overload
  template<class U>
  RDGeom::Point3D &getAtomPos(U atomId) {
      return getAtomPos(rdcast<unsigned int>(atomId));
  }

  //! Set the position of the specified atom
  inline void setAtomPos(unsigned int atomId, const RDGeom::Point3D &position) {
    // RANGE_CHECK(0,atomId,d_positions.size()-1);
    if (atomId >= d_positions.size()) {
      d_positions.resize(atomId + 1, RDGeom::Point3D(0.0, 0.0, 0.0));
    }
    d_positions[atomId] = position;
  }
  //! overload
  template<class U>
  void setAtomPos(U atomId, const RDGeom::Point3D &position) {
      return setAtomPos(rdcast<unsigned int>(atomId), position);
  }
  //! get the ID of this conformer
  inline unsigned int getId() const { return d_id; }

  //! set the ID of this conformer
  inline void setId(unsigned int id) { d_id = id; }

  //! Get the number of atoms
  inline unsigned int getNumAtoms() const { return rdcast<unsigned int>(d_positions.size()); }

  inline bool is3D() const { return df_is3D; }
  inline void set3D(bool v) { df_is3D = v; }

 protected:
  //! Set owning moelcule
  void setOwningMol(ROMol *mol);

  //! Set owning moelcule
  void setOwningMol(ROMol &mol);

 private:
  bool df_is3D;                      // is this a 3D conformation?
  unsigned int d_id;                 // id is the conformation
  ROMol *dp_mol;                     // owning molecule
  RDGeom::POINT3D_VECT d_positions;  // positions of the atoms
};

typedef boost::shared_ptr<Conformer> CONFORMER_SPTR;
}

#endif

APT Browse - Built by Thomas Orozco.