MacroMol core (rdkit#9373)

Author: emilyrrhodes

Code/GraphMol/Atom.cpp

@@ -217,6 +217,8 @@ void Atom::initFromOther(const Atom &other) {
   } else {
     dp_monomerInfo = nullptr;
   }
+  dp_macroAtomInfo =
+      other.dp_macroAtomInfo ? other.dp_macroAtomInfo->copy() : nullptr;
   d_flags = other.d_flags;
 }
 
@@ -633,6 +635,10 @@ void Atom::setMonomerInfo(AtomMonomerInfo *info) {
   dp_monomerInfo = info;
 }
 
+void Atom::setMacroAtomInfo(MacroAtomInfo *info) {
+  dp_macroAtomInfo.reset(info);
+}
+
 void Atom::setIsotope(unsigned int what) { d_isotope = what; }
 
 double Atom::getMass() const {

Code/GraphMol/Atom.h

@@ -17,13 +17,15 @@
 #define _RD_ATOM_H
 
 #include <limits>
+#include <memory>
 
 // ours
 #include <RDGeneral/Invariant.h>
 #include <Query/QueryObjects.h>
 #include <RDGeneral/types.h>
 #include <RDGeneral/RDProps.h>
 #include <GraphMol/details.h>
+#include <GraphMol/MacroAtomInfo.h>
 
 namespace RDKit {
 class Atom;
@@ -36,7 +38,6 @@ namespace RDKit {
 class ROMol;
 class RWMol;
 class AtomMonomerInfo;
-
 //! The class for representing atoms
 /*!
 
@@ -370,6 +371,13 @@ class RDKIT_GRAPHMOL_EXPORT Atom : public RDProps {
   //! takes ownership of the pointer
   void setMonomerInfo(AtomMonomerInfo *info);
 
+  MacroAtomInfo *getMacroAtomInfo() { return dp_macroAtomInfo.get(); }
+  const MacroAtomInfo *getMacroAtomInfo() const {
+    return dp_macroAtomInfo.get();
+  }
+  //! takes ownership of the pointer
+  void setMacroAtomInfo(MacroAtomInfo *info);
+
   //! Set the atom map Number of the atom
   void setAtomMapNum(int mapno, bool strict = true) {
     PRECONDITION(
@@ -422,6 +430,7 @@ class RDKIT_GRAPHMOL_EXPORT Atom : public RDProps {
 
   ROMol *dp_mol;
   AtomMonomerInfo *dp_monomerInfo;
+  std::unique_ptr<MacroAtomInfo> dp_macroAtomInfo;
   void initAtom();
   void initFromOther(const Atom &other);
 };

Code/GraphMol/Bond.cpp

@@ -35,6 +35,8 @@ Bond::Bond(const Bond &other) : RDProps(other) {
   } else {
     dp_stereoAtoms = nullptr;
   }
+  dp_macroBondInfo =
+      other.dp_macroBondInfo ? other.dp_macroBondInfo->copy() : nullptr;
   df_isAromatic = other.df_isAromatic;
   df_isConjugated = other.df_isConjugated;
   d_index = other.d_index;
@@ -58,6 +60,8 @@ Bond &Bond::operator=(const Bond &other) {
   } else {
     dp_stereoAtoms = nullptr;
   }
+  dp_macroBondInfo =
+      other.dp_macroBondInfo ? other.dp_macroBondInfo->copy() : nullptr;
   df_isAromatic = other.df_isAromatic;
   df_isConjugated = other.df_isConjugated;
   d_index = other.d_index;
@@ -77,6 +81,10 @@ void Bond::setOwningMol(ROMol *other) {
   dp_mol = other;
 }
 
+void Bond::setMacroBondInfo(MacroBondInfo *info) {
+  dp_macroBondInfo.reset(info);
+}
+
 unsigned int Bond::getOtherAtomIdx(const unsigned int thisIdx) const {
   if (d_beginAtomIdx == thisIdx) {
     return d_endAtomIdx;

Code/GraphMol/Bond.h

@@ -12,6 +12,7 @@
 #define RD_BOND_H
 
 // std stuff
+#include <memory>
 #include <utility>
 
 // Ours
@@ -20,6 +21,7 @@
 #include <RDGeneral/types.h>
 #include <RDGeneral/RDProps.h>
 #include <GraphMol/details.h>
+#include <GraphMol/MacroBondInfo.h>
 
 namespace RDKit {
 class ROMol;
@@ -124,6 +126,7 @@ class RDKIT_GRAPHMOL_EXPORT Bond : public RDProps {
     // the molecule will still be pointing to the original object
     dp_mol = std::exchange(o.dp_mol, nullptr);
     dp_stereoAtoms = std::exchange(o.dp_stereoAtoms, nullptr);
+    dp_macroBondInfo = std::move(o.dp_macroBondInfo);
     d_flags = std::exchange(o.d_flags, 0);
   }
   Bond &operator=(Bond &&o) noexcept {
@@ -144,6 +147,7 @@ class RDKIT_GRAPHMOL_EXPORT Bond : public RDProps {
     delete dp_stereoAtoms;
     dp_mol = std::exchange(o.dp_mol, nullptr);
     dp_stereoAtoms = std::exchange(o.dp_stereoAtoms, nullptr);
+    dp_macroBondInfo = std::move(o.dp_macroBondInfo);
     d_flags = std::exchange(o.d_flags, 0);
     return *this;
   }
@@ -362,6 +366,13 @@ class RDKIT_GRAPHMOL_EXPORT Bond : public RDProps {
     return *dp_stereoAtoms;
   }
 
+  MacroBondInfo *getMacroBondInfo() { return dp_macroBondInfo.get(); }
+  const MacroBondInfo *getMacroBondInfo() const {
+    return dp_macroBondInfo.get();
+  }
+  //! takes ownership of the pointer
+  void setMacroBondInfo(MacroBondInfo *info);
+
   //! calculates any of our lazy \c properties
   /*!
     <b>Notes:</b>
@@ -384,6 +395,7 @@ class RDKIT_GRAPHMOL_EXPORT Bond : public RDProps {
   /// void setOwningMol(ROMol &other) { setOwningMol(&other); }
   ROMol *dp_mol;
   INT_VECT *dp_stereoAtoms;
+  std::unique_ptr<MacroBondInfo> dp_macroBondInfo;
   atomindex_t d_index;
   atomindex_t d_beginAtomIdx, d_endAtomIdx;
   bool df_isAromatic;

Code/GraphMol/CMakeLists.txt

@@ -1,6 +1,9 @@
 rdkit_library(GraphMol
         Atom.cpp QueryAtom.cpp QueryBond.cpp Bond.cpp
-        MolOps.cpp FindRings.cpp ROMol.cpp RWMol.cpp PeriodicTable.cpp
+        MolOps.cpp FindRings.cpp ROMol.cpp RWMol.cpp
+        MacroAtomInfo.cpp
+        MacroMol.cpp
+        PeriodicTable.cpp
         atomic_data.cpp QueryOps.cpp MolPickler.cpp Canon.cpp
         AtomIterators.cpp BondIterators.cpp Aromaticity.cpp Kekulize.cpp
         ConjugHybrid.cpp AddHs.cpp
@@ -42,6 +45,9 @@ rdkit_headers(Atom.h
         Rings.h
         ROMol.h
         RWMol.h
+        MacroAtomInfo.h
+        MacroBondInfo.h
+        MacroMol.h
         SanitException.h
         SubstanceGroup.h
         StereoGroup.h
@@ -208,4 +214,7 @@ rdkit_catch_test(tableTestsCatch catch_periodictable.cpp
 rdkit_catch_test(molopsTestsCatch catch_molops.cpp
         LINK_LIBRARIES FileParsers SmilesParse GraphMol)
 
-rdkit_catch_test(ringSystemsTest ring_systems_test.cpp LINK_LIBRARIES SmilesParse GraphMol RDStreams)
+rdkit_catch_test(testMacroMol testMacroMol.cpp
+        LINK_LIBRARIES SmilesParse GraphMol)
+        
+rdkit_catch_test(ringSystemsTest ring_systems_test.cpp LINK_LIBRARIES SmilesParse GraphMol RDStreams)

Code/GraphMol/MacroAtomInfo.cpp

@@ -0,0 +1,50 @@
+//
+//  Copyright (C) 2026 Schrödinger and other RDKit contributors
+//
+//   @@ 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.
+//
+#include "MacroAtomInfo.h"
+
+#include <RDGeneral/Invariant.h>
+#include <RDGeneral/RDLog.h>
+
+#include <array>
+#include <utility>
+
+namespace RDKit {
+namespace {
+const std::array<std::pair<MonomerClass, const char *>, 4> monomerClassNames = {
+    {
+        {MonomerClass::AminoAcid, "AminoAcid"},
+        {MonomerClass::NucleicAcid, "NucleicAcid"},
+        {MonomerClass::Chemical, "Chemical"},
+        {MonomerClass::Other, "Other"},
+    }};
+}  // namespace
+
+const char *monomerClassToString(MonomerClass monomerClass) {
+  for (const auto &[value, name] : monomerClassNames) {
+    if (value == monomerClass) {
+      return name;
+    }
+  }
+  POSTCONDITION(false, "unknown monomer class");
+  return "";
+}
+
+MonomerClass monomerClassFromString(const std::string &monomerClass) {
+  for (const auto &[value, name] : monomerClassNames) {
+    if (monomerClass == name) {
+      return value;
+    }
+  }
+  BOOST_LOG(rdWarningLog) << "unrecognized monomer class '" << monomerClass
+                          << "'; treating it as Other" << std::endl;
+  return MonomerClass::Other;
+}
+
+}  // namespace RDKit

Code/GraphMol/MacroAtomInfo.h

@@ -0,0 +1,102 @@
+//
+//  Copyright (C) 2026 Schrödinger and other RDKit contributors
+//
+//   @@ 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 MacroAtomInfo.h
+
+  \brief Defines atom-level macro atom information
+
+*/
+#ifndef RD_MACROATOMINFO_H
+#define RD_MACROATOMINFO_H
+
+#include <RDGeneral/export.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace RDKit {
+
+//! Classes of monomer that a macro atom can represent.
+/*!
+  Supported monomer classes for macro atoms.
+
+  A regular enum is used here because MonomerClass appears in public MacroMol
+  method signatures. RDKit's BETTER_ENUM macro can expand to different C++
+  types depending on per-source-file preprocessor settings, which can cause
+  link errors in shared-library and unity builds.
+*/
+enum MonomerClass : int {
+  AminoAcid,
+  NucleicAcid,
+  Chemical,
+  Other
+};
+
+//! Converts a macro atom monomer class enum value to its recognized name.
+RDKIT_GRAPHMOL_EXPORT const char *monomerClassToString(
+    MonomerClass monomerClass);
+
+//! Converts a recognized macro atom monomer class name to its enum value.
+RDKIT_GRAPHMOL_EXPORT MonomerClass
+monomerClassFromString(const std::string &monomerClass);
+
+//! Captures atom-level information for macro atoms.
+/*!
+  Macro atom information is owned by an Atom and stores the macro atom's
+  display symbol and monomer class.
+*/
+class RDKIT_GRAPHMOL_EXPORT MacroAtomInfo {
+ public:
+  virtual ~MacroAtomInfo() = default;
+
+  MacroAtomInfo() = default;
+
+  //! Construct macro atom information.
+  /*!
+    \param symbol       the symbol used to identify the monomer
+    \param monomerClass the class of monomer the macro atom represents
+  */
+  MacroAtomInfo(std::string symbol,
+                MonomerClass monomerClass = MonomerClass::Other)
+      : d_symbol(std::move(symbol)), d_monomerClass(monomerClass) {}
+  MacroAtomInfo(const MacroAtomInfo &other) = default;
+
+  //! Returns the macro atom symbol.
+  const std::string &getSymbol() const { return d_symbol; }
+
+  //! Sets the macro atom symbol.
+  /*!
+    \param symbol the symbol used to identify the monomer
+  */
+  void setSymbol(const std::string &symbol) { d_symbol = symbol; }
+
+  //! Returns the macro atom monomer class.
+  MonomerClass getMonomerClass() const { return d_monomerClass; }
+
+  //! Sets the macro atom monomer class.
+  /*!
+    \param monomerClass the class of monomer the macro atom represents
+  */
+  void setMonomerClass(MonomerClass monomerClass) {
+    d_monomerClass = monomerClass;
+  }
+
+  //! Returns a copy of this macro atom information.
+  virtual std::unique_ptr<MacroAtomInfo> copy() const {
+    return std::make_unique<MacroAtomInfo>(*this);
+  }
+
+ private:
+  std::string d_symbol{""};
+  MonomerClass d_monomerClass{MonomerClass::Other};
+};
+}  // namespace RDKit
+
+#endif