WIP on class diagrams

docs/classes/classes.md

@@ -0,0 +1,9 @@
+---
+layout: default
+title: Classes
+has_children: true
+permalink: /classes/
+---
+
+# Classes
+{: .no_toc}

docs/classes/connectiontable.md

@@ -0,0 +1,29 @@
+---
+layout: default
+title: ConnectionTable
+parent: Classes
+---
+
+# ConnectionTable
+
+## Diagram
+```mermaid
+classDiagram
+    note for ConnectionTable "Tracks connection PseudoAtoms and their endpoints."
+    note for ConnectionTable "PseudoAtom : OBAtom#42;
+    AtomSet : set<OBAtom#42;>"
+    class ConnectionTable {
+        - OBMol#42; parent_net
+        - map<PseudoAtom, pair<PseudoAtom, PseudoAtom>> conn2endpts
+        - map<PseudoAtom, set<PseudoAtom>> endpt_conns
+        + ConnectionTable(OBMol#42; parent=NULL) ConnectionTable
+        + AddConn(PseduoAtom conn, PseudoAtom begin, PseudoAtom end) void
+        + RemoveConn(PseudoAtom conn) void
+        + IsConn(PseudoAtom atom) bool
+        + GetAtomConns(PseudoAtom endpt) AtomSet
+        + HasNeighbor(PseudoAtom begin, PseudoAtom end) bool
+        + GetConnEndpointSet(PseudoAtom conn) AtomSet
+        + GetConnEndpoints(PseudoAtom conn) pair<PseudoAtom, PseudoAtom>
+        + GetInternalConns(VirtualMol atoms) VirtualMol
+    }
+```

docs/classes/deconstructor.md

@@ -0,0 +1,43 @@
+---
+layout: default
+title: Deconstructor
+parent: Classes
+---
+
+# Deconstructor
+
+## Diagram
+```mermaid
+classDiagram
+    note for Deconstructor "Base class for MOF deconstruction algorithms
+    to go from an OBMol to its simplified net, topology,
+    and mapping of net PseudoAtoms back to the MOF."
+    class Deconstructor {
+        - string output_dir
+        - Deconstructor(const Deconstructor& other) Deconstructor
+        - operator=(const Deconstructor&) Deconstructor&
+        # OBMol#42; parent_molp
+        # Topology simplified_net
+        # OBConersion obconv
+        # bool infinite_node_detected
+        # VirtualMol points_of_extension
+        # virtual InitOutputFormat() void
+        # static GetBasicSMILES(OBMol fragment) string
+        # virtual DetectInitialNodesAndLinkers() void
+        # virtual CollapseLinkers() void
+        # virtual CollapseNodes() bool
+        # virtual SimplifyTopology() void
+        # virtual PostSimplification() void
+        # CheckCatenation() int
+        # GetCatenationInfo(int num_nets) string
+        + Deconstructor(OBMol#42; orig_mof) Deconstructor
+        + virtual ~Deconstructor()
+        + SimplifyMOF(bool write_intermediate_cifs=true) void
+        + SetOutputDir(const string& path) void
+        + virtual WriteCIFs() void
+        + virtual GetMOFInfo() string
+        + GetOutputPath(const string& filename) string
+        + WriteSimplifiedNet(const strnig& base_filename) void
+        + WriteAtomsOfRole(const string& simplified_role, const string& base_filename="") void
+    }
+```

docs/classes/mappedmol.md

@@ -0,0 +1,26 @@
+---
+layout: default
+title: MappedMol
+parent: Classes
+---
+
+# MappedMol
+
+## Diagram
+```mermaid
+classDiagram
+    note for MappedMol "OBMol copy with a one-to-one mapping
+    between original and copied OBAtom objects."
+    note for MappedMol "atom_map_t : map<OBAtom#42;, OBAtom#42;>"
+    class MappedMol {
+        - MappedMol(const MappedMol& other) MappedMol
+        - operator=(const MappedMol&) MappedMol&
+        + OBMol mol_copy
+        + OBMol#42; origin_molp
+        + atom_map_t origin_to_copy
+        + atom_map_t copy_to_orign
+        + map<OBAtom#42;, VirtualMol> copy_pa_to_multiple
+        + MappedMol() MappedMol
+        + virtual ~MappedMol()
+    }
+```

docs/classes/metaloxodeconstructor.md

@@ -0,0 +1,21 @@
+---
+layout: default
+title: MetalOxoDeconstructor
+parent: Classes
+---
+
+# MetalOxoDeconstructor
+
+## Diagram
+```mermaid
+classDiagram
+    class MetalOxoDeconstructor {
+        # virtual PostSimplification() void
+        # PAsToUniqueInChIs(VirtualMol pa, const string& format) vector<string>
+        + MetalOxoDeconstructor(OBMol#42; orig_mof=NULL) MetalOxoDeconstructor
+        + virtual ~MetalOxoDeconstructor()
+        + GetMOFkey(const string& topology=DEFAULT_MOFKEY_TOPOLOGY) string
+        + GetLinkerInChIs() string
+        + GetLinkerStats(string sep="\t") string
+    }
+```

docs/classes/pseudoatommap.md

@@ -0,0 +1,24 @@
+---
+layout: default
+title: PseudoAtomMap
+parent: Classes
+---
+
+# PseudoAtomMap
+
+## Diagram
+```mermaid
+classDiagram
+    note for PseudoAtomMap "Maps PseudoAtoms in a simplified _pseudo_mol
+    to sets of atoms in the original _full_mol"
+    note for PseudoAtomMap "PseudoAtom : OBAtom#42;"
+    class PseudoAtomMap {
+        - OBMol#42; _pseudo_mol
+        - OBMol#42; _full_mol
+        - map<PseudoAtom, VirtualMol> _mapping
+        + PseudoAtomMap(OBMol#42; pseudo=NULL, OBMol#42; orig=NULL) PseudoAtomMap
+        + ToCombinedMol(bool export_bonds=true, bool copy_bonds=true) OBMol
+        + operator[](PseudoAtom i) VirtualMol&
+        + RemoveAtom(PseudoAtom atom) void
+    }
+```

docs/classes/standardisolateddeconstructor.md

@@ -0,0 +1,18 @@
+---
+layout: default
+title: StandardIsolatedDeconstructor
+parent: Classes
+---
+
+# StandardIsolatedDeconstructor
+
+## Diagram
+```mermaid
+classDiagram
+    note for StandardIsolatedDeconstructor "Same approach as ToposPro standard representation,
+    which considers each metal atom as a vertex
+    in the simplified net."
+    class StandardIsolatedDeconstructor {
+        # virtual DetectInitialNodesAndLinkers() void
+    }
+```

docs/classes/topology.md

@@ -0,0 +1,59 @@
+---
+layout: default
+title: Topology
+parent: Classes
+---
+
+# Topology
+
+## Diagram
+```mermaid
+classDiagram
+    note for Topology "A simplified net including explicit connections
+    of PseudoAtoms, initially copied and mapped back to an original
+    parent OBMol. Unlike an OBMol, PseudoAtoms are connected by an 
+    explicit connector OBAtom#42; that allows two PseudoAtoms to be 
+    connected in different directions."
+    note for Topology "PseudoAtom : OBAtom#42;"
+    class Topology {
+        - static const int DEFAULT_ELEMENT=6
+        - static const int CONNECTION_ELEMENT=118
+        - OBMol#42; orig_molp
+        - OBMol simplified_net
+        - ConnectionTable conns
+        - map<string, VirtualMol> deleted_atoms
+        - PseudoAtomMap pa_to_act
+        - map<OBAtom#42;, string> pa_roles
+        - map<OBAtom#42;, PseudoAtom> act_to_pa
+        - Topology(const Topology& other) Topology
+        - operator=(const Topology&) Topology&
+        + Topology(OBMol#42; parent_mol=NULL) Topology
+        + GetOrigMol() OBMol#42;
+        + AtomHasRole(PseudoAtom atom, const string& role) bool
+        + GetAtomsOfRole(const string& role) VirtualMol
+        + SetRoleToAtom(const string& role, PseudoAtom atom) void
+        + SetRoleToAtoms(const string& role, VirtualMol atoms) void
+        + GetRoleFromAtom(PseudoAtom atom) string
+        + GetAtoms(bool include_conn=true) VirtualMol
+        + FragmentToOBMolNoConn(VirtualMol pa_fragment) OBMol
+        + GetDeletedOrigAtoms(const string& deletion_reason=ALL_DELETED_ORIG_ATOMS) VirtualMol
+        + GetConnectors() VirtualMol
+        + IsConnection(PseudoAtom a) bool
+        + GetOtherEndpoint(PseudoAtom conn, PseudoAtom begin) PseudoAtom
+        + OrigToPseudo(VirtualMol orig_atoms) VirtualMol
+        + PseudoToOrig(VirtualMol pa_atoms) VirtualMol
+        + FragmentWithoutConns(VirtualMol fragment) VirtualMol
+        + FragmentWithIntConns(VirtualMol fragment) VirtualMol
+        + ConnectAtoms(PseudoAtom begin, PseudoAtom end, vector3#42; pos=NULL) PseudoAtom
+        + DeleteConnection(PseudoAtom conn) void
+        + DeleteAtomAndConns(PseudoAtom atom, const string& role_for_orig_atoms=DELETE_ORIG_ATOM_ERROR) void
+        + CollapseFragment(VirtualMol pa_fragment) PseudoAtom
+        + MergeAtomToAnother(PseudoAtom from, PseudoAtom to) void
+        + SimplifyAxB() int
+        + SplitFourVertexIntoTwoThree(PseudoAtom site) int
+        + ConnTo2cPA(PseudoAtom conn_pa, int element=DEFAULT_ELEMENT) PseudoAtom
+        + ToOBMol() OBMol
+        + ToSimplifiedCIF(const string& filename) void
+        + WriteSystre(const string& filepath, bool write_centers=true, bool simplify_two_conn=true) void
+    }
+```

docs/classes/virtualmol.md

@@ -0,0 +1,37 @@
+---
+layout: default
+title: VirtualMol
+parent: Classes
+---
+
+# VirtualMol
+
+## Diagram
+```mermaid
+classDiagram
+    note for VirtualMol "A lightweight subset of OBAtom#42; in a molecule.
+    An alternative to copying OBMol objects, 
+    which undesirably creates new OBAtom objects."
+    note for VirtualMol "AtomPair : pair<OBAtom#42;, OBAtom#42;>
+    ConnIntToExt : set<AtomPair>
+    AtomSet : set<OBAtom#42;>"
+    class VirtualMol {
+        - set<OBAtom#42;> _atoms
+        - OBMol#42; _parent_mol
+        + VirtualMol(OBMol#42; parent=NULL) VirtualMol
+        + VirtualMol(OBAtom#42; single_atom) VirtualMol
+        + GetParent() OBMol#42;
+        + NumAtoms() int
+        + GetAtoms() set<OBAtom#42;>
+        + HasAtom(OBAtom#42; a) bool
+        + AddAtom(OBAtom#42; a) bool
+        + RemoveAtom(OBAtom#42; a) bool
+        + AddVirtualMol(VirtualMol addition) bool
+        + ImportCopiedFragment(OBMol#42; fragment) int
+        + GetExternalBondsOrConns() ConnIntToExt
+        + CopyToMappedMol(MappedMol#42; dest, bool export_bonds=true, bool copy_bonds=true) void
+        + ToOBMol(bool export_bonds=true, bool copy_bonds=true) OBMol
+        + ToCIF(const string& filename, bool write_bonds=true) void
+        + Separate() vector<VirtualMol>
+    }
+```