SubstanceGroup.h
Go to the documentation of this file.
//
//
// Copyright (C) 2002-2018 Greg Landrum and T5 Informatics GmbH
//
// @@ 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.
//
/*! \file SubstanceGroup.h
\brief Defines the SubstanceGroup class
*/
#include <RDGeneral/export.h>
#ifndef _RD_SGROUP_H
#define _RD_SGROUP_H
#include <unordered_map>
#include <Geometry/point.h>
#include <RDGeneral/types.h>
#include <RDGeneral/RDProps.h>
#include <boost/smart_ptr.hpp>
namespace RDKit {
class ROMol;
class Bond;
class Atom;
//! used to indicate errors from incorrect sgroup access
class RDKIT_GRAPHMOL_EXPORT SubstanceGroupException
: public std::runtime_error {
public:
//! construct with an error message
SubstanceGroupException(const char *msg) : std::runtime_error(msg){};
//! construct with an error message
SubstanceGroupException(const std::string &msg) : std::runtime_error(msg){};
};
//! The class for representing SubstanceGroups
/*!
<b>Notes:</b>
- These are inspired by the SGroups in the MDL formats
- Implementation is based on 2010 MDL SD specification:
http://infochim.u-strasbg.fr/recherche/Download/Fragmentor/MDL_SDF.pdf
- See SGroups.md for further, more comprehensive notes.
*/
class RDKIT_GRAPHMOL_EXPORT SubstanceGroup : public RDProps {
public:
//! Bond type (see V3000 spec)
enum class BondType {
XBOND, // External/Crossing bond
CBOND, // Internal/Contained bond
};
typedef std::array<RDGeom::Point3D, 3> Bracket;
//! Data structure for SAP lines (see V3000 spec)
//! lvIdx may not be set; this signaled with value -1
struct AttachPoint {
unsigned int aIdx;
int lvIdx;
std::string id;
bool operator==(const AttachPoint &other) const {
return aIdx == other.aIdx && lvIdx == other.lvIdx && id == other.id;
}
};
//! See specification for V3000 CSTATE
//! vector may or not be considered, depending on TYPE
struct CState {
unsigned int bondIdx;
RDGeom::Point3D vector;
bool operator==(const CState &other) const {
// note that we ignore coordinates for this
return bondIdx == other.bondIdx;
}
};
//! No default constructor
SubstanceGroup() = delete;
//! Main Constructor. Ownership is only set on this side of the relationship:
//! mol->addSubstanceGroup(sgroup) still needs to be called to get ownership
//! on the other side.
SubstanceGroup(ROMol *owning_mol, const std::string &type);
SubstanceGroup(const SubstanceGroup &other) = default;
SubstanceGroup(SubstanceGroup &&other) = default;
SubstanceGroup &operator=(const SubstanceGroup &other) = default;
SubstanceGroup &operator=(SubstanceGroup &&other) = default;
//! Destructor
~SubstanceGroup(){};
//! returns whether or not this belongs to a molecule
bool hasOwningMol() const { return dp_mol != nullptr; };
//! Get the molecule that owns this instance
ROMol &getOwningMol() const {
PRECONDITION(dp_mol, "no owner");
return *dp_mol;
}
//! get the index of this sgroup in dp_mol's sgroups vector
//! (do not mistake this by the ID!)
unsigned int getIndexInMol() const;
/* Atom and Bond methods */
void addAtomWithIdx(unsigned int idx);
void addParentAtomWithIdx(unsigned int idx);
void addBondWithIdx(unsigned int idx);
void addAtomWithBookmark(int mark);
void addParentAtomWithBookmark(int mark);
void addBondWithBookmark(int mark);
void addBracket(const Bracket &bracket);
void addCState(unsigned int bondIdx, const RDGeom::Point3D &vector);
void addAttachPoint(unsigned int aIdx, int lvIdx, const std::string &idStr);
BondType getBondType(unsigned int bondIdx) const;
const std::vector<unsigned int> &getAtoms() const { return d_atoms; }
const std::vector<unsigned int> &getParentAtoms() const { return d_patoms; }
const std::vector<unsigned int> &getBonds() const { return d_bonds; }
const std::vector<Bracket> &getBrackets() const { return d_brackets; }
const std::vector<CState> &getCStates() const { return d_cstates; }
const std::vector<AttachPoint> &getAttachPoints() const { return d_saps; }
//! Set owning molecule
//! This only updates atoms and bonds; parent sgroup has to be updated
//! independently, since parent might not exist at the time this is called.
void setOwningMol(ROMol *mol);
bool operator==(const SubstanceGroup &other) const {
// we ignore brackets and cstates, which involve coordinates
return dp_mol == other.dp_mol && d_atoms == other.d_atoms &&
d_patoms == other.d_patoms && d_bonds == other.d_bonds &&
d_saps == other.d_saps;
}
private:
ROMol *dp_mol = nullptr; // owning molecule
std::vector<unsigned int> d_atoms;
std::vector<unsigned int> d_patoms;
std::vector<unsigned int> d_bonds;
std::vector<Bracket> d_brackets;
std::vector<CState> d_cstates;
std::vector<AttachPoint> d_saps;
};
namespace SubstanceGroupChecks {
const std::vector<std::string> sGroupTypes = {
// polymer sgroups:
"SRU", "MON", "COP", "CRO", "GRA", "MOD", "MER", "ANY",
// formulations/mixtures:
"COM", "MIX", "FOR",
// other
"SUP", "MUL", "DAT", "GEN"};
const std::vector<std::string> sGroupSubtypes = {"ALT", "RAN", "BLO"};
const std::vector<std::string> sGroupConnectTypes = {"HH", "HT", "EU"};
RDKIT_GRAPHMOL_EXPORT bool isValidType(const std::string &type);
RDKIT_GRAPHMOL_EXPORT bool isValidSubType(const std::string &type);
RDKIT_GRAPHMOL_EXPORT bool isValidConnectType(const std::string &type);
RDKIT_GRAPHMOL_EXPORT bool isSubstanceGroupIdFree(const ROMol &mol,
unsigned int id);
} // namespace SubstanceGroupChecks
//! \name SubstanceGroups and molecules
//@{
RDKIT_GRAPHMOL_EXPORT std::vector<SubstanceGroup> &getSubstanceGroups(
ROMol &mol);
RDKIT_GRAPHMOL_EXPORT const std::vector<SubstanceGroup> &getSubstanceGroups(
const ROMol &mol);
//! Add a new SubstanceGroup. A copy is added, so we can be sure that no other
//! references to the SubstanceGroup exist.
/*!
\param sgroup - SubstanceGroup to be added to the molecule.
*/
RDKIT_GRAPHMOL_EXPORT unsigned int addSubstanceGroup(ROMol &mol,
SubstanceGroup sgroup);
//@}
} // namespace RDKit
//! allows SubstanceGroup objects to be dumped to streams
RDKIT_GRAPHMOL_EXPORT std::ostream &operator<<(std::ostream &target,
const RDKit::SubstanceGroup &sg);
#endif
RDKit::SubstanceGroupException::SubstanceGroupException
SubstanceGroupException(const char *msg)
construct with an error message
Definition: SubstanceGroup.h:37
RDKit::SubstanceGroupException
used to indicate errors from incorrect sgroup access
Definition: SubstanceGroup.h:33
RDKit::SubstanceGroup::CState
Definition: SubstanceGroup.h:75
point.h
RDKit::SubstanceGroup::getBonds
const std::vector< unsigned int > & getBonds() const
Definition: SubstanceGroup.h:130
types.h
RDKit::SubstanceGroupChecks::isValidSubType
RDKIT_GRAPHMOL_EXPORT bool isValidSubType(const std::string &type)
RDKit::SubstanceGroup::getParentAtoms
const std::vector< unsigned int > & getParentAtoms() const
Definition: SubstanceGroup.h:129
RDKit::addSubstanceGroup
RDKIT_GRAPHMOL_EXPORT unsigned int addSubstanceGroup(ROMol &mol, SubstanceGroup sgroup)
RDKit::SubstanceGroup::hasOwningMol
bool hasOwningMol() const
returns whether or not this belongs to a molecule
Definition: SubstanceGroup.h:102
RDKit::SubstanceGroup
The class for representing SubstanceGroups.
Definition: SubstanceGroup.h:52
RDGeom::Point3D
Definition: point.h:46
RDKit::SubstanceGroup::AttachPoint::id
std::string id
Definition: SubstanceGroup.h:67
RDKit::SubstanceGroup::getCStates
const std::vector< CState > & getCStates() const
Definition: SubstanceGroup.h:133
RDKit::SubstanceGroupChecks::sGroupSubtypes
const std::vector< std::string > sGroupSubtypes
Definition: SubstanceGroup.h:170
RDKit::SubstanceGroup::AttachPoint::operator==
bool operator==(const AttachPoint &other) const
Definition: SubstanceGroup.h:68
RDKit::SubstanceGroupChecks::isValidConnectType
RDKIT_GRAPHMOL_EXPORT bool isValidConnectType(const std::string &type)
RDKit::SubstanceGroup::BondType
BondType
Bond type (see V3000 spec)
Definition: SubstanceGroup.h:55
operator<<
RDKIT_GRAPHMOL_EXPORT std::ostream & operator<<(std::ostream &target, const RDKit::SubstanceGroup &sg)
allows SubstanceGroup objects to be dumped to streams
RDKit::SubstanceGroupChecks::isValidType
RDKIT_GRAPHMOL_EXPORT bool isValidType(const std::string &type)
RDKit::SubstanceGroup::getAtoms
const std::vector< unsigned int > & getAtoms() const
Definition: SubstanceGroup.h:128
RDKit::SubstanceGroup::getBrackets
const std::vector< Bracket > & getBrackets() const
Definition: SubstanceGroup.h:132
RDKit::SubstanceGroup::AttachPoint::aIdx
unsigned int aIdx
Definition: SubstanceGroup.h:65
RDKit::SubstanceGroup::operator==
bool operator==(const SubstanceGroup &other) const
Definition: SubstanceGroup.h:141
RDKit::ROMol
Definition: ROMol.h:171
RDKIT_GRAPHMOL_EXPORT
#define RDKIT_GRAPHMOL_EXPORT
Definition: export.h:307
RDProps.h
RDKit::SubstanceGroup::CState::bondIdx
unsigned int bondIdx
Definition: SubstanceGroup.h:76
RDKit::SubstanceGroup::AttachPoint::lvIdx
int lvIdx
Definition: SubstanceGroup.h:66
RDKit::RDProps
Definition: RDProps.h:10
RDKit::SubstanceGroup::~SubstanceGroup
~SubstanceGroup()
Destructor.
Definition: SubstanceGroup.h:99
RDKit::SubstanceGroup::CState::operator==
bool operator==(const CState &other) const
Definition: SubstanceGroup.h:78
RDKit::SubstanceGroupChecks::sGroupTypes
const std::vector< std::string > sGroupTypes
Definition: SubstanceGroup.h:162
RDKit::SubstanceGroupChecks::sGroupConnectTypes
const std::vector< std::string > sGroupConnectTypes
Definition: SubstanceGroup.h:171
RDKit
Std stuff.
Definition: Atom.h:30
RDKit::SubstanceGroupChecks::isSubstanceGroupIdFree
RDKIT_GRAPHMOL_EXPORT bool isSubstanceGroupIdFree(const ROMol &mol, unsigned int id)
RDKit::SubstanceGroup::CState::vector
RDGeom::Point3D vector
Definition: SubstanceGroup.h:77
RDKit::SubstanceGroup::Bracket
std::array< RDGeom::Point3D, 3 > Bracket
Definition: SubstanceGroup.h:60
RDKit::SubstanceGroup::getOwningMol
ROMol & getOwningMol() const
Get the molecule that owns this instance.
Definition: SubstanceGroup.h:105
PRECONDITION
#define PRECONDITION(expr, mess)
Definition: Invariant.h:109
RDKit::SubstanceGroupException::SubstanceGroupException
SubstanceGroupException(const std::string &msg)
construct with an error message
Definition: SubstanceGroup.h:39
RDKit::SubstanceGroup::AttachPoint
Definition: SubstanceGroup.h:64
RDKit::getSubstanceGroups
RDKIT_GRAPHMOL_EXPORT std::vector< SubstanceGroup > & getSubstanceGroups(ROMol &mol)
RDKit::SubstanceGroup::getAttachPoints
const std::vector< AttachPoint > & getAttachPoints() const
Definition: SubstanceGroup.h:134
export.h