diff --git a/corelib/src/libs/SireMM/selectorbond.h b/corelib/src/libs/SireMM/selectorbond.h
index a72a71ac5..00c20df63 100644
--- a/corelib/src/libs/SireMM/selectorbond.h
+++ b/corelib/src/libs/SireMM/selectorbond.h
@@ -36,172 +36,171 @@ SIRE_BEGIN_HEADER
 
 namespace SireMM
 {
-class SelectorBond;
+    class SelectorBond;
 }
 
-SIREMM_EXPORT QDataStream& operator<<(QDataStream&, const SireMM::SelectorBond&);
-SIREMM_EXPORT QDataStream& operator>>(QDataStream&, SireMM::SelectorBond&);
+SIREMM_EXPORT QDataStream &operator<<(QDataStream &, const SireMM::SelectorBond &);
+SIREMM_EXPORT QDataStream &operator>>(QDataStream &, SireMM::SelectorBond &);
 
 namespace SireMM
 {
 
-/** This provides a Selector<T>-style interface for multiple bonds */
-class SIREMM_EXPORT SelectorBond :
-    public SireBase::ConcreteProperty<SelectorBond, SireMol::MoleculeView>
-{
+    /** This provides a Selector<T>-style interface for multiple bonds */
+    class SIREMM_EXPORT SelectorBond : public SireBase::ConcreteProperty<SelectorBond, SireMol::MoleculeView>
+    {
 
-friend QDataStream& ::operator<<(QDataStream&, const SelectorBond&);
-friend QDataStream& ::operator>>(QDataStream&, SelectorBond&);
+        friend QDataStream & ::operator<<(QDataStream &, const SelectorBond &);
+        friend QDataStream & ::operator>>(QDataStream &, SelectorBond &);
 
-public:
-    SelectorBond();
+    public:
+        SelectorBond();
 
-    SelectorBond(const Bond &bond);
+        SelectorBond(const Bond &bond);
 
-    SelectorBond(const SireMol::MoleculeData &molecule,
-                 const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorBond(const SireMol::MoleculeData &molecule,
+                     const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorBond(const MoleculeView &molecule,
-                 const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorBond(const MoleculeView &molecule,
+                     const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorBond(const SireMol::MoleculeData &molecule,
-                 const SireMol::AtomID &atom,
-                 const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorBond(const SireMol::MoleculeData &molecule,
+                     const SireMol::AtomID &atom,
+                     const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorBond(const SireMol::MoleculeData &molecule,
-                 const SireMol::AtomID &atom0, const SireMol::AtomID &atom1,
-                 const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorBond(const SireMol::MoleculeData &molecule,
+                     const SireMol::AtomID &atom0, const SireMol::AtomID &atom1,
+                     const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorBond(const SireMol::MoleculeView &molecule,
-                 const SireMol::AtomID &atom,
-                 const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorBond(const SireMol::MoleculeView &molecule,
+                     const SireMol::AtomID &atom,
+                     const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorBond(const SireMol::MoleculeView &molecule,
-                 const SireMol::BondID &bond,
-                 const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorBond(const SireMol::MoleculeView &molecule,
+                     const SireMol::BondID &bond,
+                     const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorBond(const SireMol::MoleculeView &molecule,
-                 const QList<SireMol::BondID> &bonds,
-                 const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorBond(const SireMol::MoleculeView &molecule,
+                     const QList<SireMol::BondID> &bonds,
+                     const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorBond(const SireMol::MoleculeView &molecule,
-                 const SireMol::AtomID &atom0, const SireMol::AtomID &atom1,
-                 const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorBond(const SireMol::MoleculeView &molecule,
+                     const SireMol::AtomID &atom0, const SireMol::AtomID &atom1,
+                     const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorBond(const SireMol::Selector<SireMol::Atom> &atoms,
-                 const SireBase::PropertyMap &map = SireBase::PropertyMap());
-    SelectorBond(const SireMol::Selector<SireMol::Atom> &atoms0,
-                 const SireMol::Selector<SireMol::Atom> &atoms1,
-                 const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorBond(const SireMol::Selector<SireMol::Atom> &atoms,
+                     const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorBond(const SireMol::Selector<SireMol::Atom> &atoms0,
+                     const SireMol::Selector<SireMol::Atom> &atoms1,
+                     const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorBond(const SelectorBond &other);
+        SelectorBond(const SelectorBond &other);
 
-    virtual ~SelectorBond();
+        virtual ~SelectorBond();
 
-    static const char* typeName();
+        static const char *typeName();
 
-    virtual const char* what() const
-    {
-        return SelectorBond::typeName();
-    }
+        virtual const char *what() const
+        {
+            return SelectorBond::typeName();
+        }
 
-    virtual SelectorBond* clone() const
-    {
-        return new SelectorBond(*this);
-    }
+        virtual SelectorBond *clone() const
+        {
+            return new SelectorBond(*this);
+        }
 
-    SelectorBond& operator=(const SelectorBond &bond);
+        SelectorBond &operator=(const SelectorBond &bond);
 
-    bool operator==(const SelectorBond &other) const;
-    bool operator!=(const SelectorBond &other) const;
+        bool operator==(const SelectorBond &other) const;
+        bool operator!=(const SelectorBond &other) const;
 
-    QString toString() const;
+        QString toString() const;
 
-    SireMol::MolViewPtr operator[](int i) const;
-    SireMol::MolViewPtr operator[](const SireBase::Slice &slice) const;
-    SireMol::MolViewPtr operator[](const QList<qint64> &idxs) const;
-    SireMol::MolViewPtr operator[](const SireMol::BondID &bond) const;
+        SireMol::MolViewPtr operator[](int i) const;
+        SireMol::MolViewPtr operator[](const SireBase::Slice &slice) const;
+        SireMol::MolViewPtr operator[](const QList<qint64> &idxs) const;
+        SireMol::MolViewPtr operator[](const SireMol::BondID &bond) const;
 
-    Bond operator()(int i) const;
-    SelectorBond operator()(int i, int j) const;
-    SelectorBond operator()(const SireBase::Slice &slice) const;
-    SelectorBond operator()(const QList<qint64> &idxs) const;
-    SelectorBond operator()(const SireMol::BondID &bond) const;
+        Bond operator()(int i) const;
+        SelectorBond operator()(int i, int j) const;
+        SelectorBond operator()(const SireBase::Slice &slice) const;
+        SelectorBond operator()(const QList<qint64> &idxs) const;
+        SelectorBond operator()(const SireMol::BondID &bond) const;
 
-    QList<SireMol::MolViewPtr> toList() const;
+        QList<SireMol::MolViewPtr> toList() const;
 
-    bool isSelector() const;
+        bool isSelector() const;
 
-    QList<SireMol::BondID> IDs() const;
+        QList<SireMol::BondID> IDs() const;
 
-    SelectorBond add(const Bond &bond) const;
+        SelectorBond add(const Bond &bond) const;
 
-    int count() const;
-    int size() const;
-    int nViews() const;
+        int count() const;
+        int size() const;
+        int nViews() const;
 
-    bool isEmpty() const;
-    bool selectedAll() const;
+        bool isEmpty() const;
+        bool selectedAll() const;
 
-    SireMol::MolViewPtr toSelector() const;
+        SireMol::MolViewPtr toSelector() const;
 
-    SireMol::AtomSelection selection() const;
+        SireMol::AtomSelection selection() const;
 
-    SelectorBond add(const SelectorBond &other) const;
+        SelectorBond add(const SelectorBond &other) const;
 
-    SelectorBond intersection(const SelectorBond &other) const;
+        SelectorBond intersection(const SelectorBond &other) const;
 
-    SelectorBond invert(const SireBase::PropertyMap &map) const;
-    SelectorBond invert() const;
+        SelectorBond invert(const SireBase::PropertyMap &map) const;
+        SelectorBond invert() const;
 
-    bool hasProperty(const SireBase::PropertyName &key) const;
-    bool hasMetadata(const SireBase::PropertyName &key) const;
-    bool hasMetadata(const SireBase::PropertyName &key,
-                     const SireBase::PropertyName &metakey) const;
+        bool hasProperty(const SireBase::PropertyName &key) const;
+        bool hasMetadata(const SireBase::PropertyName &key) const;
+        bool hasMetadata(const SireBase::PropertyName &key,
+                         const SireBase::PropertyName &metakey) const;
 
-    QStringList propertyKeys() const;
-    QStringList metadataKeys() const;
-    QStringList metadataKeys(const SireBase::PropertyName &key) const;
+        QStringList propertyKeys() const;
+        QStringList metadataKeys() const;
+        QStringList metadataKeys(const SireBase::PropertyName &key) const;
 
-    QList<SireBase::Properties> properties() const;
+        QList<SireBase::Properties> properties() const;
 
-    SireMol::Mover<SelectorBond> move() const;
-    SireMol::Evaluator evaluate() const;
+        SireMol::Mover<SelectorBond> move() const;
+        SireMol::Evaluator evaluate() const;
 
-    QList<SireBase::PropertyPtr> property(const SireBase::PropertyName &key) const;
-    QList<SireBase::PropertyPtr> property(const SireBase::PropertyName &key,
-                                          const Property &default_value) const;
+        QList<SireBase::PropertyPtr> property(const SireBase::PropertyName &key) const;
+        QList<SireBase::PropertyPtr> property(const SireBase::PropertyName &key,
+                                              const Property &default_value) const;
 
-    QList<SireUnits::Dimension::Length> lengths() const;
-    QList<SireUnits::Dimension::Length> lengths(const SireBase::PropertyMap &map) const;
+        QList<SireUnits::Dimension::Length> lengths() const;
+        QList<SireUnits::Dimension::Length> lengths(const SireBase::PropertyMap &map) const;
 
-    QList<SireUnits::Dimension::Length> measures() const;
-    QList<SireUnits::Dimension::Length> measures(const SireBase::PropertyMap &map) const;
+        QList<SireUnits::Dimension::Length> measures() const;
+        QList<SireUnits::Dimension::Length> measures(const SireBase::PropertyMap &map) const;
 
-    QList<SireCAS::Expression> potentials() const;
-    QList<SireCAS::Expression> potentials(const SireBase::PropertyMap &map) const;
+        QList<SireCAS::Expression> potentials() const;
+        QList<SireCAS::Expression> potentials(const SireBase::PropertyMap &map) const;
 
-    QList<SireUnits::Dimension::GeneralUnit> energies() const;
-    QList<SireUnits::Dimension::GeneralUnit> energies(
-                            const SireBase::PropertyMap &map) const;
+        QList<SireUnits::Dimension::GeneralUnit> energies() const;
+        QList<SireUnits::Dimension::GeneralUnit> energies(
+            const SireBase::PropertyMap &map) const;
 
-    SireUnits::Dimension::GeneralUnit energy() const;
-    SireUnits::Dimension::GeneralUnit energy(
-                            const SireBase::PropertyMap &map) const;
+        SireUnits::Dimension::GeneralUnit energy() const;
+        SireUnits::Dimension::GeneralUnit energy(
+            const SireBase::PropertyMap &map) const;
 
-protected:
-    /** The IDs of the bond (holding AtomIdx IDs) */
-    QList<SireMol::BondID> bnds;
-};
+    protected:
+        /** The IDs of the bond (holding AtomIdx IDs) */
+        QList<SireMol::BondID> bnds;
+    };
 
 } // end of namespace SireMM
 
-Q_DECLARE_METATYPE( SireMM::SelectorBond )
-Q_DECLARE_METATYPE( SireMol::Mover<SireMM::SelectorBond> )
+Q_DECLARE_METATYPE(SireMM::SelectorBond)
+Q_DECLARE_METATYPE(SireMol::Mover<SireMM::SelectorBond>)
 
-SIRE_EXPOSE_CLASS( SireMM::SelectorBond )
+SIRE_EXPOSE_CLASS(SireMM::SelectorBond)
 
-SIRE_EXPOSE_ALIAS( SireMol::Mover<SireMM::SelectorBond>, SireMol::Mover_SelectorBond_ )
+SIRE_EXPOSE_ALIAS(SireMol::Mover<SireMM::SelectorBond>, SireMol::Mover_SelectorBond_)
 
 #ifdef SIRE_INSTANTIATE_TEMPLATES
 
diff --git a/corelib/src/libs/SireMM/selectormbond.h b/corelib/src/libs/SireMM/selectormbond.h
index 316b26980..2e278bdb6 100644
--- a/corelib/src/libs/SireMM/selectormbond.h
+++ b/corelib/src/libs/SireMM/selectormbond.h
@@ -33,321 +33,320 @@
 
 #include "selectorbond.h"
 
-
 SIRE_BEGIN_HEADER
 
 namespace SireMol
 {
-class Atom;
-class Residue;
-class Chain;
-class Segment;
-class CutGroup;
-class Molecule;
-class MoleculeGroup;
-class Molecules;
-class SelectResult;
-
-class SelectorMol;
-class EvaluatorM;
+    class Atom;
+    class Residue;
+    class Chain;
+    class Segment;
+    class CutGroup;
+    class Molecule;
+    class MoleculeGroup;
+    class Molecules;
+    class SelectResult;
+
+    class SelectorMol;
+    class EvaluatorM;
 
 }
 
 namespace SireMM
 {
-class SelectorMBond;
+    class SelectorMBond;
 }
 
-SIREMM_EXPORT QDataStream& operator<<(QDataStream&, const SireMM::SelectorMBond&);
-SIREMM_EXPORT QDataStream& operator>>(QDataStream&, SireMM::SelectorMBond&);
+SIREMM_EXPORT QDataStream &operator<<(QDataStream &, const SireMM::SelectorMBond &);
+SIREMM_EXPORT QDataStream &operator>>(QDataStream &, SireMM::SelectorMBond &);
 
 namespace SireMM
 {
 
-/** Multi-molecule selector for bonds */
-class SIREMM_EXPORT SelectorMBond
-    : public SireBase::ConcreteProperty<SelectorMBond, SireBase::Property>
-{
+    /** Multi-molecule selector for bonds */
+    class SIREMM_EXPORT SelectorMBond
+        : public SireBase::ConcreteProperty<SelectorMBond, SireBase::Property>
+    {
 
-friend QDataStream& ::operator<<(QDataStream&, const SelectorMBond&);
-friend QDataStream& ::operator>>(QDataStream&, SelectorMBond&);
+        friend QDataStream & ::operator<<(QDataStream &, const SelectorMBond &);
+        friend QDataStream & ::operator>>(QDataStream &, SelectorMBond &);
 
-public:
-    typedef QList<SelectorBond>::const_iterator const_iterator;
-    typedef QList<SelectorBond>::const_iterator iterator;
+    public:
+        typedef QList<SelectorBond>::const_iterator const_iterator;
+        typedef QList<SelectorBond>::const_iterator iterator;
 
-    SelectorMBond();
-    SelectorMBond(const Bond &view);
+        SelectorMBond();
+        SelectorMBond(const Bond &view);
 
-    SelectorMBond(const SireMol::Molecules &mols,
-                  const SireBase::PropertyMap &map = SireBase::PropertyMap());
-    SelectorMBond(const SireMol::MoleculeGroup &mols,
-                  const SireBase::PropertyMap &map = SireBase::PropertyMap());
-    SelectorMBond(const SireMol::MolGroupsBase &mols,
-                  const SireBase::PropertyMap &map = SireBase::PropertyMap());
-    SelectorMBond(const SireMol::SelectResult &mols,
-                  const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorMBond(const SireMol::Molecules &mols,
+                      const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorMBond(const SireMol::MoleculeGroup &mols,
+                      const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorMBond(const SireMol::MolGroupsBase &mols,
+                      const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorMBond(const SireMol::SelectResult &mols,
+                      const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorMBond(const SelectorBond &bonds);
+        SelectorMBond(const SelectorBond &bonds);
 
-    SelectorMBond(const SireMol::SelectorMol &mols,
-                  const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorMBond(const SireMol::SelectorMol &mols,
+                      const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    template<class U>
-    SelectorMBond(const SireMol::SelectorM<U> &other,
-                  const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        template <class U>
+        SelectorMBond(const SireMol::SelectorM<U> &other,
+                      const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorMBond(const SelectorMBond &bonds, const SireBase::Slice &slice);
-    SelectorMBond(const SelectorMBond &bonds, const QList<qint64> &idxs);
+        SelectorMBond(const SelectorMBond &bonds, const SireBase::Slice &slice);
+        SelectorMBond(const SelectorMBond &bonds, const QList<qint64> &idxs);
 
-    SelectorMBond(const SireMol::SelectResult &mols,
-                  const SireMol::BondID &bond,
-                  const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorMBond(const SireMol::SelectResult &mols,
+                      const SireMol::BondID &bond,
+                      const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorMBond(const SireMol::SelectorM<SireMol::Atom> &atoms,
-                  const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorMBond(const SireMol::SelectorM<SireMol::Atom> &atoms,
+                      const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorMBond(const SireMol::SelectorM<SireMol::Atom> &atoms0,
-                  const SireMol::SelectorM<SireMol::Atom> &atoms1,
-                  const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorMBond(const SireMol::SelectorM<SireMol::Atom> &atoms0,
+                      const SireMol::SelectorM<SireMol::Atom> &atoms1,
+                      const SireBase::PropertyMap &map = SireBase::PropertyMap());
 
-    SelectorMBond(const SelectorMBond &other);
+        SelectorMBond(const SelectorMBond &other);
 
-    virtual ~SelectorMBond();
+        virtual ~SelectorMBond();
 
-    static const char* typeName();
+        static const char *typeName();
 
-    virtual SelectorMBond* clone() const
-    {
-        return new SelectorMBond(*this);
-    }
+        virtual SelectorMBond *clone() const
+        {
+            return new SelectorMBond(*this);
+        }
 
-    SelectorMBond& operator=(const SelectorMBond &other);
-
-    bool operator==(const SelectorMBond &other) const;
-    bool operator!=(const SelectorMBond &other) const;
-
-    Bond operator[](int i) const;
-    SelectorMBond operator[](const SireBase::Slice &slice) const;
-    SelectorMBond operator[](const QList<qint64> &idxs) const;
-    SelectorMBond operator[](const SireMol::BondID &id) const;
-
-    Bond operator()(int i) const;
-    SelectorMBond operator()(const SireBase::Slice &slice) const;
-    SelectorMBond operator()(const QList<qint64> &idxs) const;
-    SelectorMBond operator()(const SireMol::BondID &id) const;
-
-    QList<SireMol::MolViewPtr> toList() const;
-    SireMol::Molecules toMolecules() const;
-
-    int count() const;
-    int size() const;
-
-    void update(const SireMol::Molecules &molecules);
-
-    SireMol::EvaluatorM evaluate() const;
-
-    bool isSelector() const;
-
-    SireMol::MoleculeGroup toMoleculeGroup() const;
-    SireMol::SelectResult toSelectResult() const;
-
-    SireMol::Molecule molecule(int i,
-                               const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::Molecule molecule(const QString &name,
-                               const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::Molecule molecule(const SireMol::MolID &molid,
-                               const SireBase::PropertyMap &map=SireBase::PropertyMap());
-
-    SireMol::SelectorMol molecules() const;
-    SireMol::SelectorMol molecules(int i,
-                                   const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorMol molecules(const SireBase::Slice &slice,
-                                   const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorMol molecules(const QList<qint64> &idxs,
-                                   const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorMol molecules(const QString &name,
-                                   const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorMol molecules(const SireMol::MolID &molid,
-                                   const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SireMol::Atom atom(int i,
-                       const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::Atom atom(const QString &name,
-                       const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::Atom atom(const SireMol::AtomID &atomid,
-                       const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SireMol::Residue residue(int i,
-                             const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::Residue residue(const QString &name,
-                             const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::Residue residue(const SireMol::ResID &resid,
-                             const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SireMol::Chain chain(int i,
-                         const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::Chain chain(const QString &name,
-                         const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::Chain chain(const SireMol::ChainID &chainid,
-                         const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SireMol::Segment segment(int i,
-                             const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::Segment segment(const QString &name,
-                             const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::Segment segment(const SireMol::SegID &segid,
-                             const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SireMol::CutGroup cutGroup(int i,
-                               const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::CutGroup cutGroup(const QString &name,
-                               const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::CutGroup cutGroup(const SireMol::CGID &cgid,
-                               const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SireMol::SelectorM<SireMol::Atom> atoms() const;
-    SireMol::SelectorM<SireMol::Atom> atoms(int i,
-                                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Atom> atoms(const SireBase::Slice &slice,
-                                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Atom> atoms(const QList<qint64> &idxs,
-                                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Atom> atoms(const QString &name,
-                                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Atom> atoms(const SireMol::AtomID &atomid,
-                                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SireMol::SelectorM<SireMol::Residue> residues() const;
-    SireMol::SelectorM<SireMol::Residue> residues(int i,
-                                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Residue> residues(const SireBase::Slice &slice,
-                                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Residue> residues(const QList<qint64> &idxs,
-                                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Residue> residues(const QString &name,
-                                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Residue> residues(const SireMol::ResID &resid,
-                                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SireMol::SelectorM<SireMol::Chain> chains() const;
-    SireMol::SelectorM<SireMol::Chain> chains(int i,
-                                              const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Chain> chains(const SireBase::Slice &slice,
-                                              const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Chain> chains(const QList<qint64> &idxs,
-                                              const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Chain> chains(const QString &name,
-                                              const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Chain> chains(const SireMol::ChainID &chainid,
-                                              const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SireMol::SelectorM<SireMol::Segment> segments() const;
-    SireMol::SelectorM<SireMol::Segment> segments(int i,
-                                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Segment> segments(const SireBase::Slice &slice,
-                                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Segment> segments(const QList<qint64> &idxs,
-                                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Segment> segments(const QString &name,
-                                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::Segment> segments(const SireMol::SegID &segid,
-                                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SireMol::SelectorM<SireMol::CutGroup> cutGroups() const;
-    SireMol::SelectorM<SireMol::CutGroup> cutGroups(int i,
-                                                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::CutGroup> cutGroups(const SireBase::Slice &slice,
-                                                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::CutGroup> cutGroups(const QList<qint64> &idxs,
-                                                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::CutGroup> cutGroups(const QString &name,
-                                                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SireMol::SelectorM<SireMol::CutGroup> cutGroups(const SireMol::CGID &cgid,
-                                                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectorMBond add(const SelectorMBond &other) const;
-
-    SelectorMBond intersection(const SelectorMBond &other) const;
-
-    SelectorMBond invert(const SireBase::PropertyMap &map) const;
-    SelectorMBond invert() const;
-
-    bool hasProperty(const SireBase::PropertyName &key) const;
-    bool hasMetadata(const SireBase::PropertyName &key) const;
-    bool hasMetadata(const SireBase::PropertyName &key,
-                     const SireBase::PropertyName &metakey) const;
-
-    QStringList propertyKeys() const;
-    QStringList metadataKeys() const;
-    QStringList metadataKeys(const SireBase::PropertyName &key) const;
-
-    QList<SireBase::Properties> properties() const;
-
-    QList<SireBase::PropertyPtr> property(const SireBase::PropertyName &key) const;
-    QList<SireBase::PropertyPtr> property(const SireBase::PropertyName &key,
-                                          const Property &default_value) const;
-
-    QList<SireUnits::Dimension::Length> lengths() const;
-    QList<SireUnits::Dimension::Length> lengths(const SireBase::PropertyMap &map) const;
-
-    QList<SireUnits::Dimension::Length> measures() const;
-    QList<SireUnits::Dimension::Length> measures(const SireBase::PropertyMap &map) const;
-
-    QList<SireCAS::Expression> potentials() const;
-    QList<SireCAS::Expression> potentials(const SireBase::PropertyMap &map) const;
-
-    QList<SireUnits::Dimension::GeneralUnit> energies() const;
-    QList<SireUnits::Dimension::GeneralUnit> energies(
-                            const SireBase::PropertyMap &map) const;
-
-    SireUnits::Dimension::GeneralUnit energy() const;
-    SireUnits::Dimension::GeneralUnit energy(
-                            const SireBase::PropertyMap &map) const;
-
-    SireMol::SelectResult search(const QString &search_string) const;
-    SireMol::SelectResult search(const QString &search_string,
-                                 const SireBase::PropertyMap &map) const;
-
-    QList<SireMol::BondID> IDs() const;
-
-    int nAtoms() const;
-    int nResidues() const;
-    int nChains() const;
-    int nSegments() const;
-    int nCutGroups() const;
-    int nMolecules() const;
-
-    bool isEmpty() const;
-
-    int nFrames() const;
-    int nFrames(const SireBase::PropertyMap &map) const;
-
-    void loadFrame(int frame);
-    void saveFrame(int frame);
-    void saveFrame();
-    void deleteFrame(int frame);
-
-    void loadFrame(int frame, const SireBase::PropertyMap &map);
-    void saveFrame(int frame, const SireBase::PropertyMap &map);
-    void saveFrame(const SireBase::PropertyMap &map);
-    void deleteFrame(int frame, const SireBase::PropertyMap &map);
-
-    const_iterator begin() const;
-    const_iterator end() const;
-
-    const_iterator constBegin() const;
-    const_iterator constEnd() const;
+        SelectorMBond &operator=(const SelectorMBond &other);
+
+        bool operator==(const SelectorMBond &other) const;
+        bool operator!=(const SelectorMBond &other) const;
+
+        Bond operator[](int i) const;
+        SelectorMBond operator[](const SireBase::Slice &slice) const;
+        SelectorMBond operator[](const QList<qint64> &idxs) const;
+        SelectorMBond operator[](const SireMol::BondID &id) const;
+
+        Bond operator()(int i) const;
+        SelectorMBond operator()(const SireBase::Slice &slice) const;
+        SelectorMBond operator()(const QList<qint64> &idxs) const;
+        SelectorMBond operator()(const SireMol::BondID &id) const;
+
+        QList<SireMol::MolViewPtr> toList() const;
+        SireMol::Molecules toMolecules() const;
+
+        int count() const;
+        int size() const;
+
+        void update(const SireMol::Molecules &molecules);
+
+        SireMol::EvaluatorM evaluate() const;
+
+        bool isSelector() const;
+
+        SireMol::MoleculeGroup toMoleculeGroup() const;
+        SireMol::SelectResult toSelectResult() const;
+
+        SireMol::Molecule molecule(int i,
+                                   const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::Molecule molecule(const QString &name,
+                                   const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::Molecule molecule(const SireMol::MolID &molid,
+                                   const SireBase::PropertyMap &map = SireBase::PropertyMap());
+
+        SireMol::SelectorMol molecules() const;
+        SireMol::SelectorMol molecules(int i,
+                                       const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorMol molecules(const SireBase::Slice &slice,
+                                       const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorMol molecules(const QList<qint64> &idxs,
+                                       const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorMol molecules(const QString &name,
+                                       const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorMol molecules(const SireMol::MolID &molid,
+                                       const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SireMol::Atom atom(int i,
+                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::Atom atom(const QString &name,
+                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::Atom atom(const SireMol::AtomID &atomid,
+                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SireMol::Residue residue(int i,
+                                 const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::Residue residue(const QString &name,
+                                 const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::Residue residue(const SireMol::ResID &resid,
+                                 const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SireMol::Chain chain(int i,
+                             const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::Chain chain(const QString &name,
+                             const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::Chain chain(const SireMol::ChainID &chainid,
+                             const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SireMol::Segment segment(int i,
+                                 const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::Segment segment(const QString &name,
+                                 const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::Segment segment(const SireMol::SegID &segid,
+                                 const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SireMol::CutGroup cutGroup(int i,
+                                   const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::CutGroup cutGroup(const QString &name,
+                                   const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::CutGroup cutGroup(const SireMol::CGID &cgid,
+                                   const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SireMol::SelectorM<SireMol::Atom> atoms() const;
+        SireMol::SelectorM<SireMol::Atom> atoms(int i,
+                                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Atom> atoms(const SireBase::Slice &slice,
+                                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Atom> atoms(const QList<qint64> &idxs,
+                                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Atom> atoms(const QString &name,
+                                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Atom> atoms(const SireMol::AtomID &atomid,
+                                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SireMol::SelectorM<SireMol::Residue> residues() const;
+        SireMol::SelectorM<SireMol::Residue> residues(int i,
+                                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Residue> residues(const SireBase::Slice &slice,
+                                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Residue> residues(const QList<qint64> &idxs,
+                                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Residue> residues(const QString &name,
+                                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Residue> residues(const SireMol::ResID &resid,
+                                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SireMol::SelectorM<SireMol::Chain> chains() const;
+        SireMol::SelectorM<SireMol::Chain> chains(int i,
+                                                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Chain> chains(const SireBase::Slice &slice,
+                                                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Chain> chains(const QList<qint64> &idxs,
+                                                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Chain> chains(const QString &name,
+                                                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Chain> chains(const SireMol::ChainID &chainid,
+                                                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SireMol::SelectorM<SireMol::Segment> segments() const;
+        SireMol::SelectorM<SireMol::Segment> segments(int i,
+                                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Segment> segments(const SireBase::Slice &slice,
+                                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Segment> segments(const QList<qint64> &idxs,
+                                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Segment> segments(const QString &name,
+                                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::Segment> segments(const SireMol::SegID &segid,
+                                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SireMol::SelectorM<SireMol::CutGroup> cutGroups() const;
+        SireMol::SelectorM<SireMol::CutGroup> cutGroups(int i,
+                                                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::CutGroup> cutGroups(const SireBase::Slice &slice,
+                                                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::CutGroup> cutGroups(const QList<qint64> &idxs,
+                                                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::CutGroup> cutGroups(const QString &name,
+                                                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SireMol::SelectorM<SireMol::CutGroup> cutGroups(const SireMol::CGID &cgid,
+                                                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectorMBond add(const SelectorMBond &other) const;
+
+        SelectorMBond intersection(const SelectorMBond &other) const;
+
+        SelectorMBond invert(const SireBase::PropertyMap &map) const;
+        SelectorMBond invert() const;
+
+        bool hasProperty(const SireBase::PropertyName &key) const;
+        bool hasMetadata(const SireBase::PropertyName &key) const;
+        bool hasMetadata(const SireBase::PropertyName &key,
+                         const SireBase::PropertyName &metakey) const;
+
+        QStringList propertyKeys() const;
+        QStringList metadataKeys() const;
+        QStringList metadataKeys(const SireBase::PropertyName &key) const;
+
+        QList<SireBase::Properties> properties() const;
+
+        QList<SireBase::PropertyPtr> property(const SireBase::PropertyName &key) const;
+        QList<SireBase::PropertyPtr> property(const SireBase::PropertyName &key,
+                                              const Property &default_value) const;
+
+        QList<SireUnits::Dimension::Length> lengths() const;
+        QList<SireUnits::Dimension::Length> lengths(const SireBase::PropertyMap &map) const;
+
+        QList<SireUnits::Dimension::Length> measures() const;
+        QList<SireUnits::Dimension::Length> measures(const SireBase::PropertyMap &map) const;
+
+        QList<SireCAS::Expression> potentials() const;
+        QList<SireCAS::Expression> potentials(const SireBase::PropertyMap &map) const;
+
+        QList<SireUnits::Dimension::GeneralUnit> energies() const;
+        QList<SireUnits::Dimension::GeneralUnit> energies(
+            const SireBase::PropertyMap &map) const;
+
+        SireUnits::Dimension::GeneralUnit energy() const;
+        SireUnits::Dimension::GeneralUnit energy(
+            const SireBase::PropertyMap &map) const;
+
+        SireMol::SelectResult search(const QString &search_string) const;
+        SireMol::SelectResult search(const QString &search_string,
+                                     const SireBase::PropertyMap &map) const;
+
+        QList<SireMol::BondID> IDs() const;
+
+        int nAtoms() const;
+        int nResidues() const;
+        int nChains() const;
+        int nSegments() const;
+        int nCutGroups() const;
+        int nMolecules() const;
+
+        bool isEmpty() const;
+
+        int nFrames() const;
+        int nFrames(const SireBase::PropertyMap &map) const;
+
+        void loadFrame(int frame);
+        void saveFrame(int frame);
+        void saveFrame();
+        void deleteFrame(int frame);
+
+        void loadFrame(int frame, const SireBase::PropertyMap &map);
+        void saveFrame(int frame, const SireBase::PropertyMap &map);
+        void saveFrame(const SireBase::PropertyMap &map);
+        void deleteFrame(int frame, const SireBase::PropertyMap &map);
+
+        const_iterator begin() const;
+        const_iterator end() const;
+
+        const_iterator constBegin() const;
+        const_iterator constEnd() const;
 
-    virtual QString toString() const;
+        virtual QString toString() const;
 
-protected:
-    void _append(const Bond &bond);
-    void _append(const SelectorBond &bonds);
+    protected:
+        void _append(const Bond &bond);
+        void _append(const SelectorBond &bonds);
 
-    /** The actual bonds */
-    QList< SelectorBond > bnds;
-};
+        /** The actual bonds */
+        QList<SelectorBond> bnds;
+    };
 
 } // end of namespace SireMM
 
@@ -363,22 +362,22 @@ friend QDataStream& ::operator>>(QDataStream&, SelectorMBond&);
 namespace SireMM
 {
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMBond::SelectorMBond(const SireMol::SelectorM<T> &other,
-                             const SireBase::PropertyMap &map)
-              : SireBase::ConcreteProperty<SelectorMBond,SireBase::Property>()
-{
-    if (not other.isEmpty())
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorMBond::SelectorMBond(const SireMol::SelectorM<T> &other,
+                                 const SireBase::PropertyMap &map)
+        : SireBase::ConcreteProperty<SelectorMBond, SireBase::Property>()
     {
-        this->bnds.reserve(other.nMolecules());
-
-        for (int i=0; i<other.nMolecules(); ++i)
+        if (not other.isEmpty())
         {
-            this->bnds.append(SelectorBond(other.molecule(i), map));
+            this->bnds.reserve(other.nMolecules());
+
+            for (int i = 0; i < other.nMolecules(); ++i)
+            {
+                this->bnds.append(SelectorBond(other.molecule(i), map));
+            }
         }
     }
-}
 
 } // end of namespace SireMol
 
diff --git a/corelib/src/libs/SireMaths/freeenergyaverage.cpp b/corelib/src/libs/SireMaths/freeenergyaverage.cpp
index d640b6449..08c3247c8 100644
--- a/corelib/src/libs/SireMaths/freeenergyaverage.cpp
+++ b/corelib/src/libs/SireMaths/freeenergyaverage.cpp
@@ -52,7 +52,7 @@ static const RegisterMetaType<FreeEnergyAverage> r_avg;
 
 /** Serialise to a binary datastream */
 QDataStream &operator<<(QDataStream &ds,
-                                         const FreeEnergyAverage &avg)
+                        const FreeEnergyAverage &avg)
 {
     writeHeader(ds, r_avg, 3);
 
@@ -60,7 +60,7 @@ QDataStream &operator<<(QDataStream &ds,
 
     sds << avg.hist
         << avg.is_forwards_free_energy
-        << static_cast<const ExpAverage&>(avg);
+        << static_cast<const ExpAverage &>(avg);
 
     return ds;
 }
@@ -74,19 +74,19 @@ QDataStream &operator>>(QDataStream &ds, FreeEnergyAverage &avg)
     {
         SharedDataStream sds(ds);
 
-        sds >> avg.hist >> avg.is_forwards_free_energy >> static_cast<ExpAverage&>(avg);
+        sds >> avg.hist >> avg.is_forwards_free_energy >> static_cast<ExpAverage &>(avg);
     }
     else if (v == 2)
     {
         SharedDataStream sds(ds);
 
-        sds >> avg.hist >> static_cast<ExpAverage&>(avg);
+        sds >> avg.hist >> static_cast<ExpAverage &>(avg);
 
         avg.is_forwards_free_energy = true;
     }
     else if (v == 1)
     {
-        ds >> static_cast<ExpAverage&>(avg);
+        ds >> static_cast<ExpAverage &>(avg);
         avg.hist = Histogram();
         avg.is_forwards_free_energy = true;
     }
@@ -100,62 +100,74 @@ QDataStream &operator>>(QDataStream &ds, FreeEnergyAverage &avg)
     at room temperature (25 C) and collects statistics about the
     free energy using a histogram of bin width 0.5 kcal mol-1 */
 FreeEnergyAverage::FreeEnergyAverage()
-                  : ConcreteProperty<FreeEnergyAverage,ExpAverage>(
-                        -1.0 / (k_boltz * double(25*celsius)) ), hist(0.5)
-{}
+    : ConcreteProperty<FreeEnergyAverage, ExpAverage>(
+          -1.0 / (k_boltz.value() * double(25 * celsius))),
+      hist(0.5)
+{
+}
 
 /** Constructor - this defaults to accumulating the average
     at room temperature (25 C) and collects statistics about the
     free energy using a histogram of bin width 0.5 kcal mol-1, specifying
     whether or not this is a forwards free energy */
 FreeEnergyAverage::FreeEnergyAverage(bool forwards)
-                  : ConcreteProperty<FreeEnergyAverage,ExpAverage>(
-                        -1.0 / (k_boltz * double(25*celsius)) ), hist(0.5),
-                        is_forwards_free_energy(forwards)
-{}
+    : ConcreteProperty<FreeEnergyAverage, ExpAverage>(
+          -1.0 / (k_boltz.value() * double(25 * celsius))),
+      hist(0.5),
+      is_forwards_free_energy(forwards)
+{
+}
 
 /** Construct an accumulator to accumulate the free energy average
     at the specified temperature, and to collect statistics about
     the free energy using a histogram of bin width 0.5 kcal mol-1 */
 FreeEnergyAverage::FreeEnergyAverage(const Temperature &temperature, bool forwards)
-                  : ConcreteProperty<FreeEnergyAverage,ExpAverage>(
-                        -1.0 / (k_boltz * temperature.to(kelvin)) ), hist(0.5),
-                        is_forwards_free_energy(forwards)
-{}
+    : ConcreteProperty<FreeEnergyAverage, ExpAverage>(
+          -1.0 / (k_boltz.value() * temperature.to(kelvin))),
+      hist(0.5),
+      is_forwards_free_energy(forwards)
+{
+}
 
 /** Constructor - this defaults to accumulating the average
     at room temperature (25 C) and collects statistics about the
     free energy using a histogram of the passed bin width. If the binwidth
     is zero, then a histogram of energies is not collected */
 FreeEnergyAverage::FreeEnergyAverage(const MolarEnergy &binwidth, bool forwards)
-                  : ConcreteProperty<FreeEnergyAverage,ExpAverage>(
-                        -1.0 / (k_boltz * double(25*celsius)) ), hist(binwidth.value()),
-                        is_forwards_free_energy(forwards)
-{}
+    : ConcreteProperty<FreeEnergyAverage, ExpAverage>(
+          -1.0 / (k_boltz.value() * double(25 * celsius))),
+      hist(binwidth.value()),
+      is_forwards_free_energy(forwards)
+{
+}
 
 /** Construct an accumulator to accumulate the free energy average
     at the specified temperature, and to collect statistics about
     the free energy using a histogram of passed bin width */
 FreeEnergyAverage::FreeEnergyAverage(const Temperature &temperature,
                                      const MolarEnergy &binwidth, bool forwards)
-                  : ConcreteProperty<FreeEnergyAverage,ExpAverage>(
-                        -1.0 / (k_boltz * temperature.to(kelvin)) ), hist(binwidth.value()),
-                        is_forwards_free_energy(forwards)
-{}
+    : ConcreteProperty<FreeEnergyAverage, ExpAverage>(
+          -1.0 / (k_boltz.value() * temperature.to(kelvin))),
+      hist(binwidth.value()),
+      is_forwards_free_energy(forwards)
+{
+}
 
 /** Copy constructor */
 FreeEnergyAverage::FreeEnergyAverage(const FreeEnergyAverage &other)
-                  : ConcreteProperty<FreeEnergyAverage,ExpAverage>(other),
-                    hist(other.hist),
-                    is_forwards_free_energy(other.is_forwards_free_energy)
-{}
+    : ConcreteProperty<FreeEnergyAverage, ExpAverage>(other),
+      hist(other.hist),
+      is_forwards_free_energy(other.is_forwards_free_energy)
+{
+}
 
 /** Destructor */
 FreeEnergyAverage::~FreeEnergyAverage()
-{}
+{
+}
 
 /** Copy assignment operator */
-FreeEnergyAverage& FreeEnergyAverage::operator=(const FreeEnergyAverage &other)
+FreeEnergyAverage &FreeEnergyAverage::operator=(const FreeEnergyAverage &other)
 {
     if (this != &other)
     {
@@ -183,13 +195,15 @@ bool FreeEnergyAverage::operator!=(const FreeEnergyAverage &other) const
 }
 
 /** Combine the passed average onto this average */
-FreeEnergyAverage& FreeEnergyAverage::operator+=(const FreeEnergyAverage &other)
+FreeEnergyAverage &FreeEnergyAverage::operator+=(const FreeEnergyAverage &other)
 {
     if (is_forwards_free_energy != other.is_forwards_free_energy)
-        throw SireError::incompatible_error( QObject::tr(
-                "Cannot combine a 'forwards' free energy with a 'backwards' free energy. "
-                "%1 vs. %2").arg(this->toString()).arg(other.toString()),
-                    CODELOC );
+        throw SireError::incompatible_error(QObject::tr(
+                                                "Cannot combine a 'forwards' free energy with a 'backwards' free energy. "
+                                                "%1 vs. %2")
+                                                .arg(this->toString())
+                                                .arg(other.toString()),
+                                            CODELOC);
 
     ExpAverage::operator+=(other);
     hist += other.hist;
@@ -209,11 +223,11 @@ FreeEnergyAverage FreeEnergyAverage::operator+(const FreeEnergyAverage &other) c
     is being accumulated */
 Temperature FreeEnergyAverage::temperature() const
 {
-    return Temperature( -1.0 / (k_boltz*scaleFactor()) );
+    return Temperature(-1.0 / (k_boltz.value() * scaleFactor()));
 }
 
 /** Return the histogram of energies */
-const Histogram& FreeEnergyAverage::histogram() const
+const Histogram &FreeEnergyAverage::histogram() const
 {
     return hist;
 }
@@ -224,23 +238,23 @@ QString FreeEnergyAverage::toString() const
                        "stdev = %3 kcal mol-1, "
                        "skew = %4 kcal mol-1, nSamples = %5, "
                        "isForwardsFreeEnergy() = %6 )")
-                            .arg(this->average())
-                            .arg(histogram().mean())
-                            .arg(histogram().standardDeviation())
-                            .arg(histogram().skew())
-                            .arg(nSamples())
-                            .arg(isForwardsFreeEnergy());
+        .arg(this->average())
+        .arg(histogram().mean())
+        .arg(histogram().standardDeviation())
+        .arg(histogram().skew())
+        .arg(nSamples())
+        .arg(isForwardsFreeEnergy());
 }
 
-const char* FreeEnergyAverage::typeName()
+const char *FreeEnergyAverage::typeName()
 {
-    return QMetaType::typeName( qMetaTypeId<FreeEnergyAverage>() );
+    return QMetaType::typeName(qMetaTypeId<FreeEnergyAverage>());
 }
 
 /** Clear all data from the accumulator */
 void FreeEnergyAverage::clear()
 {
-    hist = Histogram( hist.binWidth() );
+    hist = Histogram(hist.binWidth());
     ExpAverage::clear();
 }
 
@@ -266,8 +280,8 @@ bool FreeEnergyAverage::isBackwardsFreeEnergy() const
 /** Return the Taylor series expansion estimate the difference in free energy */
 double FreeEnergyAverage::taylorExpansion() const
 {
-    double dg = hist.mean() - 0.5*k_boltz*temperature() *
-                    ( hist.meanOfSquares() - (hist.mean()*hist.mean()) );
+    double dg = hist.mean() - 0.5 * k_boltz.value() * temperature() *
+                                  (hist.meanOfSquares() - (hist.mean() * hist.mean()));
 
     if (not is_forwards_free_energy)
         dg *= -1;
@@ -288,7 +302,6 @@ double FreeEnergyAverage::fepFreeEnergy() const
     return dg;
 }
 
-
 /** Return the average free energy. Note that if this is a backwards free energy,
     then this will return the negative (so that it is easy to combine backwards
     and forwards values) */
@@ -322,7 +335,7 @@ FreeEnergyAverage::operator double() const
 static const RegisterMetaType<BennettsFreeEnergyAverage> r_bennetts;
 
 QDataStream &operator<<(QDataStream &ds,
-                                         const BennettsFreeEnergyAverage &bennetts)
+                        const BennettsFreeEnergyAverage &bennetts)
 {
     writeHeader(ds, r_bennetts, 2);
 
@@ -330,7 +343,7 @@ QDataStream &operator<<(QDataStream &ds,
 
     sds << bennetts.bennetts_avg << bennetts.bennetts_avg2
         << bennetts.const_offset
-        << static_cast<const FreeEnergyAverage&>(bennetts);
+        << static_cast<const FreeEnergyAverage &>(bennetts);
 
     return ds;
 }
@@ -343,9 +356,7 @@ QDataStream &operator>>(QDataStream &ds, BennettsFreeEnergyAverage &bennetts)
     {
         SharedDataStream sds(ds);
 
-        sds >> bennetts.bennetts_avg >> bennetts.bennetts_avg2
-            >> bennetts.const_offset
-            >> static_cast<FreeEnergyAverage&>(bennetts);
+        sds >> bennetts.bennetts_avg >> bennetts.bennetts_avg2 >> bennetts.const_offset >> static_cast<FreeEnergyAverage &>(bennetts);
     }
     else if (v == 1)
     {
@@ -353,11 +364,9 @@ QDataStream &operator>>(QDataStream &ds, BennettsFreeEnergyAverage &bennetts)
 
         MolarEnergy tmp;
 
-        sds >> bennetts.bennetts_avg >> tmp
-            >> bennetts.bennetts_avg2 >> tmp
-            >> static_cast<FreeEnergyAverage&>(bennetts);
+        sds >> bennetts.bennetts_avg >> tmp >> bennetts.bennetts_avg2 >> tmp >> static_cast<FreeEnergyAverage &>(bennetts);
 
-        bennetts.const_offset = 0*kcal_per_mol;
+        bennetts.const_offset = 0 * kcal_per_mol;
     }
     else
         throw version_error(v, "1,2", r_bennetts, CODELOC);
@@ -367,45 +376,51 @@ QDataStream &operator>>(QDataStream &ds, BennettsFreeEnergyAverage &bennetts)
 
 /** Constructor */
 BennettsFreeEnergyAverage::BennettsFreeEnergyAverage()
-     : ConcreteProperty<BennettsFreeEnergyAverage,FreeEnergyAverage>(),
-       bennetts_avg(0), bennetts_avg2(0), const_offset(0)
-{}
+    : ConcreteProperty<BennettsFreeEnergyAverage, FreeEnergyAverage>(),
+      bennetts_avg(0), bennetts_avg2(0), const_offset(0)
+{
+}
 
 /** Constructor, specifying whether or not this is a forwards free energy */
 BennettsFreeEnergyAverage::BennettsFreeEnergyAverage(bool forwards)
-     : ConcreteProperty<BennettsFreeEnergyAverage,FreeEnergyAverage>(forwards),
-       bennetts_avg(0), bennetts_avg2(0), const_offset(0)
-{}
+    : ConcreteProperty<BennettsFreeEnergyAverage, FreeEnergyAverage>(forwards),
+      bennetts_avg(0), bennetts_avg2(0), const_offset(0)
+{
+}
 
 /** Construct the average at the specified temperature */
 BennettsFreeEnergyAverage::BennettsFreeEnergyAverage(const Temperature &temperature,
                                                      bool forwards)
-     : ConcreteProperty<BennettsFreeEnergyAverage,FreeEnergyAverage>(temperature,forwards),
-       bennetts_avg(0), bennetts_avg2(0), const_offset(0)
-{}
+    : ConcreteProperty<BennettsFreeEnergyAverage, FreeEnergyAverage>(temperature, forwards),
+      bennetts_avg(0), bennetts_avg2(0), const_offset(0)
+{
+}
 
 /** Construct, specifying the value of any constant offset for the ratio (C value)
     and the temperature */
 BennettsFreeEnergyAverage::BennettsFreeEnergyAverage(const MolarEnergy &constant,
                                                      const Temperature &temperature,
                                                      bool forwards)
-     : ConcreteProperty<BennettsFreeEnergyAverage,FreeEnergyAverage>(temperature,forwards),
-       bennetts_avg(0), bennetts_avg2(0), const_offset(constant)
-{}
+    : ConcreteProperty<BennettsFreeEnergyAverage, FreeEnergyAverage>(temperature, forwards),
+      bennetts_avg(0), bennetts_avg2(0), const_offset(constant)
+{
+}
 
 /** Construct, specifying the constant offset for the ratio (C value) */
 BennettsFreeEnergyAverage::BennettsFreeEnergyAverage(const MolarEnergy &constant, bool forwards)
-     : ConcreteProperty<BennettsFreeEnergyAverage,FreeEnergyAverage>(forwards),
-       bennetts_avg(0), bennetts_avg2(0), const_offset(constant)
-{}
+    : ConcreteProperty<BennettsFreeEnergyAverage, FreeEnergyAverage>(forwards),
+      bennetts_avg(0), bennetts_avg2(0), const_offset(constant)
+{
+}
 
 /** Construct at the specified temperature, using a histogram of the specified bin width */
 BennettsFreeEnergyAverage::BennettsFreeEnergyAverage(const Temperature &temperature,
                                                      const MolarEnergy &binwidth,
                                                      bool forwards)
-     : ConcreteProperty<BennettsFreeEnergyAverage,FreeEnergyAverage>(temperature,binwidth,forwards),
-       bennetts_avg(0), bennetts_avg2(0), const_offset(0)
-{}
+    : ConcreteProperty<BennettsFreeEnergyAverage, FreeEnergyAverage>(temperature, binwidth, forwards),
+      bennetts_avg(0), bennetts_avg2(0), const_offset(0)
+{
+}
 
 /** Construct at the specified temperature, using the specificed constant (C value),
     using a histogram of the specified bin width */
@@ -413,23 +428,26 @@ BennettsFreeEnergyAverage::BennettsFreeEnergyAverage(const MolarEnergy &constant
                                                      const Temperature &temperature,
                                                      const MolarEnergy &binwidth,
                                                      bool forwards)
-     : ConcreteProperty<BennettsFreeEnergyAverage,FreeEnergyAverage>(temperature,binwidth,forwards),
-       bennetts_avg(0), bennetts_avg2(0), const_offset(constant)
-{}
+    : ConcreteProperty<BennettsFreeEnergyAverage, FreeEnergyAverage>(temperature, binwidth, forwards),
+      bennetts_avg(0), bennetts_avg2(0), const_offset(constant)
+{
+}
 
 /** Copy constructor */
 BennettsFreeEnergyAverage::BennettsFreeEnergyAverage(const BennettsFreeEnergyAverage &other)
-     : ConcreteProperty<BennettsFreeEnergyAverage,FreeEnergyAverage>(other),
-       bennetts_avg(other.bennetts_avg), bennetts_avg2(other.bennetts_avg2),
-       const_offset(other.const_offset)
-{}
+    : ConcreteProperty<BennettsFreeEnergyAverage, FreeEnergyAverage>(other),
+      bennetts_avg(other.bennetts_avg), bennetts_avg2(other.bennetts_avg2),
+      const_offset(other.const_offset)
+{
+}
 
 /** Destructor */
 BennettsFreeEnergyAverage::~BennettsFreeEnergyAverage()
-{}
+{
+}
 
 /** Copy assignment operator */
-BennettsFreeEnergyAverage&
+BennettsFreeEnergyAverage &
 BennettsFreeEnergyAverage::operator=(const BennettsFreeEnergyAverage &other)
 {
     if (this != &other)
@@ -475,19 +493,24 @@ MolarEnergy BennettsFreeEnergyAverage::constant() const
 }
 
 /** Self-addition operator */
-BennettsFreeEnergyAverage&
+BennettsFreeEnergyAverage &
 BennettsFreeEnergyAverage::operator+=(const BennettsFreeEnergyAverage &other)
 {
     if (isForwardsRatio() != other.isForwardsRatio())
-        throw SireError::incompatible_error( QObject::tr(
-                "Cannot combine a 'forwards' free energy with a 'backwards' free energy. "
-                "%1 vs. %2").arg(this->toString()).arg(other.toString()),
-                    CODELOC );
+        throw SireError::incompatible_error(QObject::tr(
+                                                "Cannot combine a 'forwards' free energy with a 'backwards' free energy. "
+                                                "%1 vs. %2")
+                                                .arg(this->toString())
+                                                .arg(other.toString()),
+                                            CODELOC);
 
     if (this->constant() != other.constant())
-        throw SireError::incompatible_error( QObject::tr(
-                "Cannot combine Bennetts averages that have different constant offsets! "
-                "%1 vs. %2").arg(this->toString()).arg(other.toString()), CODELOC );
+        throw SireError::incompatible_error(QObject::tr(
+                                                "Cannot combine Bennetts averages that have different constant offsets! "
+                                                "%1 vs. %2")
+                                                .arg(this->toString())
+                                                .arg(other.toString()),
+                                            CODELOC);
 
     double nsteps = nSamples() + other.nSamples();
 
@@ -511,9 +534,9 @@ BennettsFreeEnergyAverage::operator+(const BennettsFreeEnergyAverage &other) con
     return ret;
 }
 
-const char* BennettsFreeEnergyAverage::typeName()
+const char *BennettsFreeEnergyAverage::typeName()
 {
-    return QMetaType::typeName( qMetaTypeId<BennettsFreeEnergyAverage>() );
+    return QMetaType::typeName(qMetaTypeId<BennettsFreeEnergyAverage>());
 }
 
 QString BennettsFreeEnergyAverage::toString() const
@@ -523,15 +546,15 @@ QString BennettsFreeEnergyAverage::toString() const
                        "stderr = %5 kcal mol-1, "
                        "skew = %6 kcal mol-1, nSamples = %7, constant() = %8 kcal mol-1 "
                        "isForwardsRatio() = %9 )")
-                            .arg(this->fepFreeEnergy())
-                            .arg(histogram().mean())
-                            .arg(bennettsRatio())
-                            .arg(bennettsStandardError(90))
-                            .arg(histogram().standardError())
-                            .arg(histogram().skew())
-                            .arg(nSamples())
-                            .arg(constant().to(kcal_per_mol))
-                            .arg(isForwardsRatio());
+        .arg(this->fepFreeEnergy())
+        .arg(histogram().mean())
+        .arg(bennettsRatio())
+        .arg(bennettsStandardError(90))
+        .arg(histogram().standardError())
+        .arg(histogram().skew())
+        .arg(nSamples())
+        .arg(constant().to(kcal_per_mol))
+        .arg(isForwardsRatio());
 }
 
 /** Clear this accumulator */
@@ -559,15 +582,15 @@ void BennettsFreeEnergyAverage::accumulate(double value)
 
     if (isForwardsRatio())
     {
-        val = 1.0 / (1.0 + std::exp(-this->scaleFactor()*(value-const_offset.value())));
+        val = 1.0 / (1.0 + std::exp(-this->scaleFactor() * (value - const_offset.value())));
     }
     else
     {
-        val = 1.0 / (1.0 + std::exp(-this->scaleFactor()*(value+const_offset.value())));
+        val = 1.0 / (1.0 + std::exp(-this->scaleFactor() * (value + const_offset.value())));
     }
 
     bennetts_avg = my_ratio * bennetts_avg + other_ratio * val;
-    bennetts_avg2 = my_ratio * bennetts_avg2 + other_ratio * (val*val);
+    bennetts_avg2 = my_ratio * bennetts_avg2 + other_ratio * (val * val);
 
     FreeEnergyAverage::accumulate(value);
 }
@@ -586,6 +609,6 @@ double BennettsFreeEnergyAverage::bennettsStandardError(double level) const
     if (this->nSamples() == 0)
         return 0;
 
-    double stdev = std::sqrt( bennetts_avg2 - pow_2(bennetts_avg) );
-    return Histogram::tValue(this->nSamples(),level) * stdev / std::sqrt(this->nSamples());
+    double stdev = std::sqrt(bennetts_avg2 - pow_2(bennetts_avg));
+    return Histogram::tValue(this->nSamples(), level) * stdev / std::sqrt(this->nSamples());
 }
diff --git a/corelib/src/libs/SireMol/selector.hpp b/corelib/src/libs/SireMol/selector.hpp
index df3c57ff3..9c5afb257 100644
--- a/corelib/src/libs/SireMol/selector.hpp
+++ b/corelib/src/libs/SireMol/selector.hpp
@@ -53,1806 +53,1948 @@ SIRE_BEGIN_HEADER
 
 namespace SireMol
 {
-template<class T>
-class Selector;
+    template <class T>
+    class Selector;
+
+    template <class T>
+    class SelectorM;
 }
 
-template<class T>
-SIREMOL_EXPORT QDataStream& operator<<(QDataStream&, const SireMol::Selector<T>&);
+template <class T>
+SIREMOL_EXPORT QDataStream &operator<<(QDataStream &, const SireMol::Selector<T> &);
 
-template<class T>
-SIREMOL_EXPORT QDataStream& operator>>(QDataStream&, SireMol::Selector<T>&);
+template <class T>
+SIREMOL_EXPORT QDataStream &operator>>(QDataStream &, SireMol::Selector<T> &);
 
 namespace SireMol
 {
 
-class MoleculeData;
-
-namespace detail
-{
+    class MoleculeData;
 
-SIREMOL_EXPORT bool has_property(const Atom*, const MoleculeData &moldata,
-                  const PropertyName &key);
-SIREMOL_EXPORT bool has_property(const Chain*, const MoleculeData &moldata,
-                  const PropertyName &key);
-SIREMOL_EXPORT bool has_property(const CutGroup*, const MoleculeData &moldata,
-                  const PropertyName &key);
-SIREMOL_EXPORT bool has_property(const Residue*, const MoleculeData &moldata,
-                  const PropertyName &key);
-SIREMOL_EXPORT bool has_property(const Segment*, const MoleculeData &moldata,
-                  const PropertyName &key);
-
-SIREMOL_EXPORT bool has_metadata(const Atom*, const MoleculeData &moldata,
-                  const PropertyName &metakey);
-SIREMOL_EXPORT bool has_metadata(const Chain*, const MoleculeData &moldata,
-                  const PropertyName &metakey);
-SIREMOL_EXPORT bool has_metadata(const CutGroup*, const MoleculeData &moldata,
-                  const PropertyName &metakey);
-SIREMOL_EXPORT bool has_metadata(const Residue*, const MoleculeData &moldata,
-                  const PropertyName &metakey);
-SIREMOL_EXPORT bool has_metadata(const Segment*, const MoleculeData &moldata,
-                  const PropertyName &metakey);
-
-SIREMOL_EXPORT bool has_metadata(const Atom*, const MoleculeData &moldata,
-                  const PropertyName &key, const PropertyName &metakey);
-SIREMOL_EXPORT bool has_metadata(const Chain*, const MoleculeData &moldata,
-                  const PropertyName &key, const PropertyName &metakey);
-SIREMOL_EXPORT bool has_metadata(const CutGroup*, const MoleculeData &moldata,
-                  const PropertyName &key, const PropertyName &metakey);
-SIREMOL_EXPORT bool has_metadata(const Residue*, const MoleculeData &moldata,
-                  const PropertyName &key, const PropertyName &metakey);
-SIREMOL_EXPORT bool has_metadata(const Segment*, const MoleculeData &moldata,
-                  const PropertyName &key, const PropertyName &metakey);
-
-} // end of namespace detail
-
-/** This template class provides a way to manipulate the selection
-    of parts of a a molecule, e.g. Selector<Atom> provides a
-    MoleculeView that has a user-configurable view of an
-    arbitrary set of atoms. This class is used by the code
-    whenever multiple groups from within the same molecule
-    are returned, e.g. when returning all residues that
-    have a particular name
-
-    @author Christopher Woods
-*/
-template<class T>
-class SIREMOL_EXPORT Selector : public SireBase::ConcreteProperty<Selector<T>,MoleculeView>
-{
+    namespace detail
+    {
 
-friend SIREMOL_EXPORT QDataStream& ::operator<<<>(QDataStream&, const Selector<T>&);
-friend SIREMOL_EXPORT QDataStream& ::operator>><>(QDataStream&, Selector<T>&);
+        SIREMOL_EXPORT bool has_property(const Atom *, const MoleculeData &moldata,
+                                         const PropertyName &key);
+        SIREMOL_EXPORT bool has_property(const Chain *, const MoleculeData &moldata,
+                                         const PropertyName &key);
+        SIREMOL_EXPORT bool has_property(const CutGroup *, const MoleculeData &moldata,
+                                         const PropertyName &key);
+        SIREMOL_EXPORT bool has_property(const Residue *, const MoleculeData &moldata,
+                                         const PropertyName &key);
+        SIREMOL_EXPORT bool has_property(const Segment *, const MoleculeData &moldata,
+                                         const PropertyName &key);
+
+        SIREMOL_EXPORT bool has_metadata(const Atom *, const MoleculeData &moldata,
+                                         const PropertyName &metakey);
+        SIREMOL_EXPORT bool has_metadata(const Chain *, const MoleculeData &moldata,
+                                         const PropertyName &metakey);
+        SIREMOL_EXPORT bool has_metadata(const CutGroup *, const MoleculeData &moldata,
+                                         const PropertyName &metakey);
+        SIREMOL_EXPORT bool has_metadata(const Residue *, const MoleculeData &moldata,
+                                         const PropertyName &metakey);
+        SIREMOL_EXPORT bool has_metadata(const Segment *, const MoleculeData &moldata,
+                                         const PropertyName &metakey);
+
+        SIREMOL_EXPORT bool has_metadata(const Atom *, const MoleculeData &moldata,
+                                         const PropertyName &key, const PropertyName &metakey);
+        SIREMOL_EXPORT bool has_metadata(const Chain *, const MoleculeData &moldata,
+                                         const PropertyName &key, const PropertyName &metakey);
+        SIREMOL_EXPORT bool has_metadata(const CutGroup *, const MoleculeData &moldata,
+                                         const PropertyName &key, const PropertyName &metakey);
+        SIREMOL_EXPORT bool has_metadata(const Residue *, const MoleculeData &moldata,
+                                         const PropertyName &key, const PropertyName &metakey);
+        SIREMOL_EXPORT bool has_metadata(const Segment *, const MoleculeData &moldata,
+                                         const PropertyName &key, const PropertyName &metakey);
+
+    } // end of namespace detail
+
+    /** This template class provides a way to manipulate the selection
+        of parts of a a molecule, e.g. Selector<Atom> provides a
+        MoleculeView that has a user-configurable view of an
+        arbitrary set of atoms. This class is used by the code
+        whenever multiple groups from within the same molecule
+        are returned, e.g. when returning all residues that
+        have a particular name
+
+        @author Christopher Woods
+    */
+    template <class T>
+    class SIREMOL_EXPORT Selector : public SireBase::ConcreteProperty<Selector<T>, MoleculeView>
+    {
 
-public:
-    Selector();
+        friend SIREMOL_EXPORT QDataStream & ::operator<< <>(QDataStream &, const Selector<T> &);
+        friend SIREMOL_EXPORT QDataStream & ::operator>><>(QDataStream &, Selector<T> &);
 
-    Selector(const T &view);
+    public:
+        Selector();
 
-    Selector(const MoleculeData &moldata);
+        Selector(const T &view);
 
-    Selector(const MoleculeData &moldata,
-             const AtomSelection &selected_atoms);
+        Selector(const MoleculeData &moldata);
 
-    Selector(const MoleculeData &moldata, const typename T::ID &viewid);
+        Selector(const MoleculeData &moldata,
+                 const AtomSelection &selected_atoms);
 
-    Selector(const MoleculeData &moldata, const QList<typename T::Index> &idxs);
+        Selector(const MoleculeData &moldata, const typename T::ID &viewid);
 
-    Selector(const Selector<T> &other);
+        Selector(const MoleculeData &moldata, const QList<typename T::Index> &idxs);
 
-    ~Selector();
+        Selector(const Selector<T> &other);
 
-    Selector<T>& operator=(const Selector<T> &other);
-    Selector<T>& operator=(const T &view);
+        ~Selector();
 
-    static const char* typeName();
+        Selector<T> &operator=(const Selector<T> &other);
+        Selector<T> &operator=(const T &view);
 
-    Selector<T>* clone() const;
+        static const char *typeName();
 
-    QList<typename T::Index> IDs() const;
-    QList<typename T::Index> indexes() const;
-    QList<typename T::Name> names() const;
-    QList<typename T::Number> numbers() const;
+        Selector<T> *clone() const;
 
-    bool operator==(const Selector<T> &other) const;
-    bool operator!=(const Selector<T> &other) const;
+        QList<typename T::Index> IDs() const;
+        QList<typename T::Index> indexes() const;
+        QList<typename T::Name> names() const;
+        QList<typename T::Number> numbers() const;
 
-    Selector<T> operator+(const Selector<T> &other) const;
-    Selector<T> operator-(const Selector<T> &other) const;
+        bool operator==(const Selector<T> &other) const;
+        bool operator!=(const Selector<T> &other) const;
 
-    Selector<T> operator+(const typename T::ID &id) const;
-    Selector<T> operator-(const typename T::ID &id) const;
+        Selector<T> operator+(const Selector<T> &other) const;
+        Selector<T> operator-(const Selector<T> &other) const;
 
-    Selector<T> operator+(const T &view) const;
-    Selector<T> operator-(const T &view) const;
+        Selector<T> operator+(const typename T::ID &id) const;
+        Selector<T> operator-(const typename T::ID &id) const;
 
-    int nViews() const;
+        Selector<T> operator+(const T &view) const;
+        Selector<T> operator-(const T &view) const;
 
-    MolViewPtr operator[](int i) const;
-    MolViewPtr operator[](const QString &name) const;
-    MolViewPtr operator[](const SireBase::Slice &slice) const;
-    MolViewPtr operator[](const QList<qint64> &idxs) const;
-    MolViewPtr operator[](const AtomID &atomid) const;
-    MolViewPtr operator[](const ResID &resid) const;
-    MolViewPtr operator[](const CGID &cgid) const;
-    MolViewPtr operator[](const ChainID &chainid) const;
-    MolViewPtr operator[](const SegID &segid) const;
-    MolViewPtr operator[](const SireID::Index &idx) const;
+        int nViews() const;
 
-    T operator()(int i) const;
-    T operator()(const SireID::Index &idx) const;
-    Selector<T> operator()(int i, int j) const;
-    Selector<T> operator()(const SireBase::Slice &slice) const;
-    Selector<T> operator()(const QList<qint64> &idxs) const;
-    Selector<Atom> operator()(const AtomID &atomid) const;
-    Selector<Residue> operator()(const ResID &resid) const;
-    Selector<CutGroup> operator()(const CGID &cgid) const;
-    Selector<Chain> operator()(const ChainID &chainid) const;
-    Selector<Segment> operator()(const SegID &segid) const;
+        MolViewPtr operator[](int i) const;
+        MolViewPtr operator[](const QString &name) const;
+        MolViewPtr operator[](const SireBase::Slice &slice) const;
+        MolViewPtr operator[](const QList<qint64> &idxs) const;
+        MolViewPtr operator[](const AtomID &atomid) const;
+        MolViewPtr operator[](const ResID &resid) const;
+        MolViewPtr operator[](const CGID &cgid) const;
+        MolViewPtr operator[](const ChainID &chainid) const;
+        MolViewPtr operator[](const SegID &segid) const;
+        MolViewPtr operator[](const SireID::Index &idx) const;
 
-    typename T::Index index(int i) const;
+        T operator()(int i) const;
+        T operator()(const SireID::Index &idx) const;
+        Selector<T> operator()(int i, int j) const;
+        Selector<T> operator()(const SireBase::Slice &slice) const;
+        Selector<T> operator()(const QList<qint64> &idxs) const;
+        Selector<Atom> operator()(const AtomID &atomid) const;
+        Selector<Residue> operator()(const ResID &resid) const;
+        Selector<CutGroup> operator()(const CGID &cgid) const;
+        Selector<Chain> operator()(const ChainID &chainid) const;
+        Selector<Segment> operator()(const SegID &segid) const;
 
-    MolViewPtr toSelector() const;
-    QList<MolViewPtr> toList() const;
+        typename T::Index index(int i) const;
 
-    Molecules toMolecules() const;
+        MolViewPtr toSelector() const;
+        QList<MolViewPtr> toList() const;
 
-    QString toString() const;
+        Molecules toMolecules() const;
 
-    bool isEmpty() const;
-    bool selectedAll() const;
+        QString toString() const;
 
-    bool isSelector() const;
+        bool isEmpty() const;
+        bool selectedAll() const;
 
-    Selector<T> add(const Selector<T> &other) const;
-    Selector<T> add(const T &view) const;
-    Selector<T> add(const typename T::ID &id) const;
+        bool isSelector() const;
 
-    Selector<T> subtract(const Selector<T> &other) const;
-    Selector<T> subtract(const T &view) const;
-    Selector<T> subtract(const typename T::ID &id) const;
+        Selector<T> add(const Selector<T> &other) const;
+        Selector<T> add(const T &view) const;
+        Selector<T> add(const typename T::ID &id) const;
 
-    Selector<T> intersection(const Selector<T> &other) const;
-    Selector<T> intersection(const T &view) const;
-    Selector<T> intersection(const typename T::ID &id) const;
+        Selector<T> subtract(const Selector<T> &other) const;
+        Selector<T> subtract(const T &view) const;
+        Selector<T> subtract(const typename T::ID &id) const;
 
-    Selector<T> invert() const;
+        Selector<T> intersection(const Selector<T> &other) const;
+        Selector<T> intersection(const T &view) const;
+        Selector<T> intersection(const typename T::ID &id) const;
 
-    bool intersects(const Selector<T> &other) const;
-    bool intersects(const T &view) const;
-    bool intersects(const typename T::ID &id) const;
+        Selector<T> invert() const;
 
-    bool contains(const Selector<T> &other) const;
-    bool contains(const T &view) const;
-    bool contains(const typename T::ID &id) const;
+        QList<qint64> find(const T &view) const;
+        QList<qint64> find(const Selector<T> &views) const;
+        QList<qint64> find(const SelectorM<T> &views) const;
 
-    AtomSelection selection() const;
-    AtomSelection selection(int i) const;
-    AtomSelection selection(int i, int j) const;
+        bool intersects(const Selector<T> &other) const;
+        bool intersects(const T &view) const;
+        bool intersects(const typename T::ID &id) const;
 
-    Mover< Selector<T> > move() const;
-    Mover< Selector<T> > move(int i) const;
-    Mover< Selector<T> > move(int i, int j) const;
+        bool contains(const Selector<T> &other) const;
+        bool contains(const T &view) const;
+        bool contains(const typename T::ID &id) const;
 
-    Evaluator evaluate() const;
-    Evaluator evaluate(int i) const;
-    Evaluator evaluate(int i, int j) const;
+        AtomSelection selection() const;
+        AtomSelection selection(int i) const;
+        AtomSelection selection(int i, int j) const;
 
-    Selector<T> selector() const;
-    Selector<T> selector(int i) const;
-    Selector<T> selector(int i, int j) const;
+        Mover<Selector<T>> move() const;
+        Mover<Selector<T>> move(int i) const;
+        Mover<Selector<T>> move(int i, int j) const;
 
-    bool hasProperty(const PropertyName &key) const;
-    bool hasMetadata(const PropertyName &metakey) const;
-    bool hasMetadata(const PropertyName &key,
-                     const PropertyName &metakey) const;
+        Evaluator evaluate() const;
+        Evaluator evaluate(int i) const;
+        Evaluator evaluate(int i, int j) const;
 
-    QStringList propertyKeys() const;
-    QStringList metadataKeys() const;
-    QStringList metadataKeys(const PropertyName &key) const;
+        Selector<T> selector() const;
+        Selector<T> selector(int i) const;
+        Selector<T> selector(int i, int j) const;
 
-    template<class V>
-    QList<V> property(const PropertyName &key) const;
+        bool hasProperty(const PropertyName &key) const;
+        bool hasMetadata(const PropertyName &metakey) const;
+        bool hasMetadata(const PropertyName &key,
+                         const PropertyName &metakey) const;
 
-    template<class V>
-    QList<V> metadata(const PropertyName &metakey) const;
+        QStringList propertyKeys() const;
+        QStringList metadataKeys() const;
+        QStringList metadataKeys(const PropertyName &key) const;
 
-    template<class V>
-    QList<V> metadata(const PropertyName &key,
-                      const PropertyName &metakey) const;
+        template <class V>
+        QList<V> property(const PropertyName &key) const;
 
-protected:
-    template<class V>
-    void setProperty(const QString &key, const QList<V> &values);
+        template <class V>
+        QList<V> metadata(const PropertyName &metakey) const;
 
-    template<class V>
-    void setMetadata(const QString &metakey, const QList<V> &values);
+        template <class V>
+        QList<V> metadata(const PropertyName &key,
+                          const PropertyName &metakey) const;
 
-    template<class V>
-    void setMetadata(const QString &key, const QString &metakey,
-                     const QList<V> &values);
+    protected:
+        template <class V>
+        void setProperty(const QString &key, const QList<V> &values);
 
-    template<class V>
-    void setProperty(const QString &key, const V &value);
+        template <class V>
+        void setMetadata(const QString &metakey, const QList<V> &values);
 
-    template<class V>
-    void setMetadata(const QString &metakey, V &value);
+        template <class V>
+        void setMetadata(const QString &key, const QString &metakey,
+                         const QList<V> &values);
 
-    template<class V>
-    void setMetadata(const QString &key, const QString &metakey,
-                     const V &value);
+        template <class V>
+        void setProperty(const QString &key, const V &value);
 
-private:
-    /** The list of indicies of the selected parts
-        of the molecule. This is empty if the entire
-        molecule is selected
-    */
-    QList<typename T::Index> idxs;
-};
+        template <class V>
+        void setMetadata(const QString &metakey, V &value);
 
-#ifndef SIRE_SKIP_INLINE_FUNCTIONS
+        template <class V>
+        void setMetadata(const QString &key, const QString &metakey,
+                         const V &value);
 
-/** Null constructor */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>::Selector() : SireBase::ConcreteProperty<Selector<T>,MoleculeView>()
-{}
+    private:
+        /** The list of indicies of the selected parts
+            of the molecule. This is empty if the entire
+            molecule is selected
+        */
+        QList<typename T::Index> idxs;
+    };
 
-/** Construct the set of all groups for the molecule whose
-    data is in 'moldata' */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>::Selector(const MoleculeData &moldata)
-            : SireBase::ConcreteProperty<Selector<T>,MoleculeView>(moldata)
-{}
+#ifndef SIRE_SKIP_INLINE_FUNCTIONS
 
-/** Construct the set of all groups for the molecule whose data is in 'moldata'
-    and with the specfied groups selected */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>::Selector(const MoleculeData &moldata,
-                      const QList<typename T::Index> &indexes)
-            : SireBase::ConcreteProperty<Selector<T>,MoleculeView>(moldata)
-{
-    int n = detail::getCount<T>(moldata.info());
+    /** Null constructor */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    Selector<T>::Selector() : SireBase::ConcreteProperty<Selector<T>, MoleculeView>()
+    {
+    }
 
-    //ensure all of the indexes are valid!
-    foreach (typename T::Index idx, indexes)
+    /** Construct the set of all groups for the molecule whose
+        data is in 'moldata' */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    Selector<T>::Selector(const MoleculeData &moldata)
+        : SireBase::ConcreteProperty<Selector<T>, MoleculeView>(moldata)
     {
-        idx.map(n);
     }
 
-    idxs = indexes;
-}
+    /** Construct the set of all groups for the molecule whose data is in 'moldata'
+        and with the specfied groups selected */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    Selector<T>::Selector(const MoleculeData &moldata,
+                          const QList<typename T::Index> &indexes)
+        : SireBase::ConcreteProperty<Selector<T>, MoleculeView>(moldata)
+    {
+        int n = detail::getCount<T>(moldata.info());
 
-/** Construct the set of all groups that contain at least
-    one of the atoms selected in 'selected_atoms'
+        // ensure all of the indexes are valid!
+        foreach (typename T::Index idx, indexes)
+        {
+            idx.map(n);
+        }
 
-    \throw SireError::incompatible_error
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>::Selector(const MoleculeData &moldata,
-                      const AtomSelection &selected_atoms)
-            : SireBase::ConcreteProperty<Selector<T>,MoleculeView>(moldata)
-{
-    if (selected_atoms.selectedNone())
-    {
-        this->operator=(Selector<T>());
+        idxs = indexes;
     }
-    else if (not selected_atoms.selectedAll())
+
+    /** Construct the set of all groups that contain at least
+        one of the atoms selected in 'selected_atoms'
+
+        \throw SireError::incompatible_error
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    Selector<T>::Selector(const MoleculeData &moldata,
+                          const AtomSelection &selected_atoms)
+        : SireBase::ConcreteProperty<Selector<T>, MoleculeView>(moldata)
     {
-        idxs = detail::getAll<T>(moldata.info(), selected_atoms);
+        if (selected_atoms.selectedNone())
+        {
+            this->operator=(Selector<T>());
+        }
+        else if (not selected_atoms.selectedAll())
+        {
+            idxs = detail::getAll<T>(moldata.info(), selected_atoms);
+        }
     }
-}
 
-/** Construct the set that contains only the view 'view' */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>::Selector(const T &view)
-            : SireBase::ConcreteProperty<Selector<T>,MoleculeView>(view)
-{
-    idxs.append(view.index());
-}
+    /** Construct the set that contains only the view 'view' */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    Selector<T>::Selector(const T &view)
+        : SireBase::ConcreteProperty<Selector<T>, MoleculeView>(view)
+    {
+        idxs.append(view.index());
+    }
 
-/** Construct the set of parts that match the ID 'id' from the
-    molecule whose data is in 'moldata'
-
-    \throw SireMol::missing_atom
-    \throw SireMol::missing_residue
-    \throw SireMol::missing_chain
-    \throw SireMol::missing_segment
-    \throw SireMol::missing_cutgroup
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>::Selector(const MoleculeData &moldata,
-                      const typename T::ID &viewid)
-            : SireBase::ConcreteProperty<Selector<T>,MoleculeView>(moldata)
-{
-    idxs = viewid.map(moldata.info());
+    /** Construct the set of parts that match the ID 'id' from the
+        molecule whose data is in 'moldata'
 
-    if (idxs.count() == detail::getCount<T>(moldata.info()))
+        \throw SireMol::missing_atom
+        \throw SireMol::missing_residue
+        \throw SireMol::missing_chain
+        \throw SireMol::missing_segment
+        \throw SireMol::missing_cutgroup
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    Selector<T>::Selector(const MoleculeData &moldata,
+                          const typename T::ID &viewid)
+        : SireBase::ConcreteProperty<Selector<T>, MoleculeView>(moldata)
     {
-        idxs.clear();
+        idxs = viewid.map(moldata.info());
+
+        if (idxs.count() == detail::getCount<T>(moldata.info()))
+        {
+            idxs.clear();
+        }
+        else if (idxs.isEmpty())
+        {
+            this->operator=(Selector<T>());
+        }
     }
-    else if (idxs.isEmpty())
+
+    /** Copy constructor */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    Selector<T>::Selector(const Selector<T> &other)
+        : SireBase::ConcreteProperty<Selector<T>, MoleculeView>(other),
+          idxs(other.idxs)
     {
-        this->operator=(Selector<T>());
     }
-}
 
-/** Copy constructor */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>::Selector(const Selector<T> &other)
-            : SireBase::ConcreteProperty<Selector<T>,MoleculeView>(other),
-              idxs(other.idxs)
-{}
+    /** Destructor */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>::~Selector()
+    {
+    }
 
-/** Destructor */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>::~Selector()
-{}
+    /** Copy assignment operator */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T> &
+        Selector<T>::operator=(const Selector<T> &other)
+    {
+        MoleculeView::operator=(other);
+        idxs = other.idxs;
 
-/** Copy assignment operator */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>& Selector<T>::operator=(const Selector<T> &other)
-{
-    MoleculeView::operator=(other);
-    idxs = other.idxs;
+        return *this;
+    }
 
-    return *this;
-}
+    /** Copy so that this contains just 'view' */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T> &
+        Selector<T>::operator=(const T &view)
+    {
+        MoleculeView::operator=(view);
 
-/** Copy so that this contains just 'view' */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>& Selector<T>::operator=(const T &view)
-{
-    MoleculeView::operator=(view);
+        idxs.clear();
+        idxs.append(view.index());
 
-    idxs.clear();
-    idxs.append(view.index());
+        return *this;
+    }
 
-    return *this;
-}
+    /** Comparison operator */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::operator==(const Selector<T> &other) const
+    {
+        return idxs == other.idxs and MoleculeView::operator==(other);
+    }
 
-/** Comparison operator */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::operator==(const Selector<T> &other) const
-{
-    return idxs == other.idxs and MoleculeView::operator==(other);
-}
+    /** Comparison operator */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::operator!=(const Selector<T> &other) const
+    {
+        return idxs != other.idxs or MoleculeView::operator!=(other);
+    }
 
-/** Comparison operator */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::operator!=(const Selector<T> &other) const
-{
-    return idxs != other.idxs or MoleculeView::operator!=(other);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE const char *Selector<T>::typeName()
+    {
+        return QMetaType::typeName(qMetaTypeId<Selector<T>>());
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-const char* Selector<T>::typeName()
-{
-    return QMetaType::typeName( qMetaTypeId< Selector<T> >() );
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T> *
+        Selector<T>::clone() const
+    {
+        return new Selector<T>(*this);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T>* Selector<T>::clone() const
-{
-    return new Selector<T>(*this);
-}
+    /** Return the IDs of all of the items in this selector, in the
+     *  order they appear in the selector
+     */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<typename T::Index>
+        Selector<T>::IDs() const
+    {
+        if (this->isEmpty())
+            return QList<typename T::Index>();
 
-/** Return the IDs of all of the items in this selector, in the
- *  order they appear in the selector
- */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QList<typename T::Index> Selector<T>::IDs() const
-{
-    if (this->isEmpty())
-        return QList<typename T::Index>();
+        else if (this->selectedAll())
+        {
+            const int n = detail::getCount<T>(this->data().info());
 
-    else if (this->selectedAll())
-    {
-        const int n = detail::getCount<T>(this->data().info());
+            QList<typename T::Index> ret;
+            ret.reserve(n);
 
-        QList<typename T::Index> ret;
-        ret.reserve(n);
+            for (int i = 0; i < n; ++i)
+            {
+                ret.append(typename T::Index(i));
+            }
 
-        for (int i=0; i<n; ++i)
-        {
-            ret.append(typename T::Index(i));
+            return ret;
         }
+        else
+            return idxs;
+    }
 
-        return ret;
+    /** Return the indexes of all of the items in this selector, in the
+     *  order they appear in the selector
+     */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<typename T::Index>
+        Selector<T>::indexes() const
+    {
+        return this->IDs();
     }
-    else
-        return idxs;
-}
 
-/** Return the indexes of all of the items in this selector, in the
- *  order they appear in the selector
- */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QList<typename T::Index> Selector<T>::indexes() const
-{
-    return this->IDs();
-}
+    /** Return the names of all of the items in this selector, in the
+     *  order they appear in the selector
+     */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<typename T::Name>
+        Selector<T>::names() const
+    {
+        auto indexes = this->IDs();
 
-/** Return the names of all of the items in this selector, in the
- *  order they appear in the selector
- */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QList<typename T::Name> Selector<T>::names() const
-{
-    auto indexes = this->IDs();
+        QList<typename T::Name> n;
+        n.reserve(indexes.count());
 
-    QList<typename T::Name> n;
-    n.reserve(indexes.count());
+        const auto &molinfo = this->data().info();
 
-    const auto &molinfo = this->data().info();
+        for (const auto &index : indexes)
+        {
+            n.append(molinfo.name(index));
+        }
 
-    for (const auto &index : indexes)
-    {
-        n.append( molinfo.name(index) );
+        return n;
     }
 
-    return n;
-}
+    /** Return the numbers of all of the items in this selector, in the
+     *  order they appear in the selector
+     */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<typename T::Number>
+        Selector<T>::numbers() const
+    {
+        auto indexes = this->IDs();
 
-/** Return the numbers of all of the items in this selector, in the
- *  order they appear in the selector
- */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QList<typename T::Number> Selector<T>::numbers() const
-{
-    auto indexes = this->IDs();
+        QList<typename T::Number> n;
+        n.reserve(indexes.count());
 
-    QList<typename T::Number> n;
-    n.reserve(indexes.count());
+        const auto &molinfo = this->data().info();
 
-    const auto &molinfo = this->data().info();
+        for (const auto &index : indexes)
+        {
+            n.append(molinfo.number(index));
+        }
 
-    for (const auto &index : indexes)
-    {
-        n.append( molinfo.number(index) );
+        return n;
     }
 
-    return n;
-}
-
-/** Return whether this set is empty */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::isEmpty() const
-{
-    return this->data().isEmpty();
-}
+    /** Return whether this set is empty */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::isEmpty() const
+    {
+        return this->data().isEmpty();
+    }
 
-/** Return whether or not the entire molecule is selected */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::selectedAll() const
-{
-    // have no indexes if we have selected all of the molecule
-    if (not this->isEmpty())
+    /** Return whether or not the entire molecule is selected */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::selectedAll() const
     {
-        if (idxs.isEmpty())
-            return true;
+        // have no indexes if we have selected all of the molecule
+        if (not this->isEmpty())
+        {
+            if (idxs.isEmpty())
+                return true;
 
-        const int n = detail::getCount<T>(this->data().info());
+            const int n = detail::getCount<T>(this->data().info());
 
-        if (idxs.count() >= n)
-        {
-            auto s = _list_to_set(idxs);
-            return s.count() == n;
+            if (idxs.count() >= n)
+            {
+                auto s = _list_to_set(idxs);
+                return s.count() == n;
+            }
         }
-    }
 
-    return false;
-}
-
-/** Return whether or not this is a Selector object */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::isSelector() const
-{
-    return true;
-}
+        return false;
+    }
 
-/** Return a string representation of this selector */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QString Selector<T>::toString() const
-{
-    if (this->isEmpty())
+    /** Return whether or not this is a Selector object */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::isSelector() const
     {
-        return QObject::tr("Selector<%1>::empty").arg(T::typeName());
+        return true;
     }
-    else
-    {
-        QStringList parts;
 
-        if (this->size() <= 10)
+    /** Return a string representation of this selector */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QString
+        Selector<T>::toString() const
+    {
+        if (this->isEmpty())
         {
-            for (int i=0; i<this->size(); ++i)
-            {
-                parts.append(QString("%1:  %2").arg(i).arg(this->operator()(i).toString()));
-            }
+            return QObject::tr("Selector<%1>::empty").arg(T::typeName());
         }
         else
         {
-            for (int i=0; i<5; ++i)
+            QStringList parts;
+
+            if (this->size() <= 10)
             {
-                parts.append(QString("%1:  %2").arg(i).arg(this->operator()(i).toString()));
+                for (int i = 0; i < this->size(); ++i)
+                {
+                    parts.append(QString("%1:  %2").arg(i).arg(this->operator()(i).toString()));
+                }
             }
+            else
+            {
+                for (int i = 0; i < 5; ++i)
+                {
+                    parts.append(QString("%1:  %2").arg(i).arg(this->operator()(i).toString()));
+                }
 
-            parts.append("...");
+                parts.append("...");
 
-            for (int i=this->size()-5; i<this->size(); ++i)
-            {
-                parts.append(QString("%1:  %3").arg(i).arg(this->operator()(i).toString()));
+                for (int i = this->size() - 5; i < this->size(); ++i)
+                {
+                    parts.append(QString("%1:  %3").arg(i).arg(this->operator()(i).toString()));
+                }
             }
-        }
 
-        return QObject::tr( "Selector<%1>( size=%2\n%3\n)")
-                        .arg(T::typeName()).arg(this->count())
-                        .arg(parts.join("\n"));
+            return QObject::tr("Selector<%1>( size=%2\n%3\n)")
+                .arg(T::typeName())
+                .arg(this->count())
+                .arg(parts.join("\n"));
+        }
     }
-}
 
-/** Return the sum of this selection with 'other' - items from
-    'other' are appended to this set only if they are not already
-    in this set
+    /** Return the sum of this selection with 'other' - items from
+        'other' are appended to this set only if they are not already
+        in this set
 
-    \throw SireError::incompatible_error
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::add(const Selector<T> &other) const
-{
-    if (this->selectedAll())
+        \throw SireError::incompatible_error
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::add(const Selector<T> &other) const
     {
-        if (other.isEmpty())
+        if (this->selectedAll())
+        {
+            if (other.isEmpty())
+                return *this;
+
+            MoleculeView::assertSameMolecule(other);
+
             return *this;
+        }
+        else if (other.selectedAll())
+        {
+            if (this->isEmpty())
+                return other;
 
-        MoleculeView::assertSameMolecule(other);
+            MoleculeView::assertSameMolecule(other);
 
-        return *this;
-    }
-    else if (other.selectedAll())
-    {
-        if (this->isEmpty())
-            return other;
+            // do this so that we always use the version from the left hand molecule
+            Selector<T> ret(*this);
+            ret.idxs.clear();
+            return ret;
+        }
 
         MoleculeView::assertSameMolecule(other);
 
-        // do this so that we always use the version from the left hand molecule
         Selector<T> ret(*this);
-        ret.idxs.clear();
+
+        if (ret.idxs.isEmpty())
+        {
+            // expand the indexes
+            const int n = detail::getCount<T>(this->data().info());
+            ret.idxs.reserve(n);
+
+            for (int i = 0; i < n; ++i)
+            {
+                ret.idxs.append(typename T::Index(i));
+            }
+        }
+
+        if (other.idxs.isEmpty())
+        {
+            const int n = detail::getCount<T>(this->data().info());
+            ret.idxs.reserve(ret.idxs.count() + n);
+
+            for (int i = 0; i < n; ++i)
+            {
+                ret.idxs.append(typename T::Index(i));
+            }
+        }
+        else
+        {
+            ret.idxs.reserve(ret.idxs.count() + other.idxs.count());
+
+            for (typename T::Index idx : other.idxs)
+            {
+                ret.idxs.append(idx);
+            }
+        }
+
         return ret;
     }
 
-    MoleculeView::assertSameMolecule(other);
+    /** Return the view 'view' to this set */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::add(const T &view) const
+    {
+        return this->add(Selector<T>(view));
+    }
 
-    Selector<T> ret(*this);
+    /** Return the set that has all views that match the ID 'id'
+        added
 
-    if (ret.idxs.isEmpty())
+        \throw SireMol::missing_atom
+        \throw SireMol::missing_residue
+        \throw SireMol::missing_chain
+        \throw SireMol::missing_segment
+        \throw SireMol::missing_cutgroup
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::add(const typename T::ID &id) const
     {
-        //expand the indexes
-        const int n = detail::getCount<T>(this->data().info());
-        ret.idxs.reserve(n);
+        return this->operator+(Selector<T>(this->data(), id));
+    }
+
+    /** Subtract all of the views in 'other' from this set
 
-        for (int i=0; i<n; ++i)
+        \throw SireError::incompatible_error
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::subtract(const Selector<T> &other) const
+    {
+        if (this->isEmpty())
+            return Selector<T>();
+        else if (other.selectedAll())
         {
-            ret.idxs.append(typename T::Index(i));
+            MoleculeView::assertSameMolecule(other);
+            return Selector<T>();
         }
-    }
 
-    if (other.idxs.isEmpty())
-    {
+        Selector<T> ret(*this);
+
         const int n = detail::getCount<T>(this->data().info());
-        ret.idxs.reserve(ret.idxs.count() + n);
 
-        for (int i=0; i<n; ++i)
+        if (ret.idxs.isEmpty())
         {
-            ret.idxs.append(typename T::Index(i));
+
+            for (int i = 0; i < n; ++i)
+            {
+                ret.idxs.append(typename T::Index(i));
+            }
         }
-    }
-    else
-    {
-        ret.idxs.reserve(ret.idxs.count() + other.idxs.count());
 
-        for (typename T::Index idx : other.idxs)
+        foreach (typename T::Index idx, other.idxs)
         {
-            ret.idxs.append(idx);
+            ret.idxs.removeAll(idx);
+
+            if (ret.idxs.isEmpty())
+                return Selector<T>();
         }
-    }
 
-    return ret;
-}
+        return ret;
+    }
 
-/** Return the view 'view' to this set */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::add(const T &view) const
-{
-    return this->add(Selector<T>(view));
-}
+    /** Remove the view 'view' from this set
 
-/** Return the set that has all views that match the ID 'id'
-    added
-
-    \throw SireMol::missing_atom
-    \throw SireMol::missing_residue
-    \throw SireMol::missing_chain
-    \throw SireMol::missing_segment
-    \throw SireMol::missing_cutgroup
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::add(const typename T::ID &id) const
-{
-    return this->operator+(Selector<T>(this->data(), id));
-}
+        \throw SireError::incompatible_error
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::subtract(const T &view) const
+    {
+        return this->subtract(Selector<T>(view));
+    }
 
-/** Subtract all of the views in 'other' from this set
+    /** Subtract all of the views that match the ID 'id' from
+        this set
 
-    \throw SireError::incompatible_error
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::subtract(const Selector<T> &other) const
-{
-    if (this->isEmpty())
-        return Selector<T>();
-    else if (other.selectedAll())
+        \throw SireMol::missing_atom
+        \throw SireMol::missing_residue
+        \throw SireMol::missing_chain
+        \throw SireMol::missing_segment
+        \throw SireMol::missing_cutgroup
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::subtract(const typename T::ID &id) const
     {
-        MoleculeView::assertSameMolecule(other);
-        return Selector<T>();
+        return this->subtract(Selector<T>(this->data(), id));
     }
 
-    Selector<T> ret(*this);
+    /** Syntactic sugar for add() */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::operator+(const Selector<T> &other) const
+    {
+        return this->add(other);
+    }
 
-    const int n = detail::getCount<T>(this->data().info());
+    /** Syntactic sugar for subtract() */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::operator-(const Selector<T> &other) const
+    {
+        return this->subtract(other);
+    }
 
-    if (ret.idxs.isEmpty())
+    /** Syntactic sugar for add() */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::operator+(const typename T::ID &id) const
     {
+        return this->add(id);
+    }
 
-        for (int i=0; i<n; ++i)
-        {
-            ret.idxs.append(typename T::Index(i));
-        }
+    /** Syntactic sugar for subtract() */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::operator-(const typename T::ID &id) const
+    {
+        return this->subtract(id);
     }
 
-    foreach (typename T::Index idx, other.idxs)
+    /** Syntactic sugar for add() */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::operator+(const T &view) const
     {
-        ret.idxs.removeAll(idx);
+        return this->add(view);
+    }
 
-        if (ret.idxs.isEmpty())
-            return Selector<T>();
+    /** Syntactic sugar for subtract() */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::operator-(const T &view) const
+    {
+        return this->subtract(view);
     }
 
-    return ret;
-}
+    /** Return the ith view in this set (this supports negative indexing!)
 
-/** Remove the view 'view' from this set
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::operator[](int i) const
+    {
+        return this->operator()(i);
+    }
 
-    \throw SireError::incompatible_error
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::subtract(const T &view) const
-{
-    return this->subtract(Selector<T>(view));
-}
-
-/** Subtract all of the views that match the ID 'id' from
-    this set
-
-    \throw SireMol::missing_atom
-    \throw SireMol::missing_residue
-    \throw SireMol::missing_chain
-    \throw SireMol::missing_segment
-    \throw SireMol::missing_cutgroup
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::subtract(const typename T::ID &id) const
-{
-    return this->subtract(Selector<T>(this->data(), id));
-}
-
-/** Syntactic sugar for add() */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::operator+(const Selector<T> &other) const
-{
-    return this->add(other);
-}
-
-/** Syntactic sugar for subtract() */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::operator-(const Selector<T> &other) const
-{
-    return this->subtract(other);
-}
-
-/** Syntactic sugar for add() */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::operator+(const typename T::ID &id) const
-{
-    return this->add(id);
-}
-
-/** Syntactic sugar for subtract() */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::operator-(const typename T::ID &id) const
-{
-    return this->subtract(id);
-}
-
-/** Syntactic sugar for add() */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::operator+(const T &view) const
-{
-    return this->add(view);
-}
-
-/** Syntactic sugar for subtract() */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::operator-(const T &view) const
-{
-    return this->subtract(view);
-}
-
-/** Return the ith view in this set (this supports negative indexing!)
-
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::operator[](int i) const
-{
-    return this->operator()(i);
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::operator[](const QString &name) const
-{
-    auto match = this->operator()(AtomName(name));
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::operator[](const QString &name) const
+    {
+        auto match = this->operator()(AtomName(name));
 
-    if (match.nAtoms() == 1)
-        return match(0);
-    else
-        return match;
-}
+        if (match.nAtoms() == 1)
+            return match(0);
+        else
+            return match;
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::operator[](const SireBase::Slice &slice) const
-{
-    return this->operator()(slice);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::operator[](const SireBase::Slice &slice) const
+    {
+        return this->operator()(slice);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::operator[](const QList<qint64> &idxs) const
-{
-    return this->operator()(idxs);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::operator[](const QList<qint64> &idxs) const
+    {
+        return this->operator()(idxs);
+    }
 
-/** Exposing MoleculeView::operator[] */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::operator[](const AtomID &atom) const
-{
-    auto match = this->operator()(atom);
+    /** Exposing MoleculeView::operator[] */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::operator[](const AtomID &atom) const
+    {
+        auto match = this->operator()(atom);
 
-    if (match.nAtoms() == 1)
-        return match(0);
-    else
-        return match;
-}
+        if (match.nAtoms() == 1)
+            return match(0);
+        else
+            return match;
+    }
 
-/** Exposing MoleculeView::operator[] */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::operator[](const ResID &res) const
-{
-    auto match = this->operator()(res);
+    /** Exposing MoleculeView::operator[] */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::operator[](const ResID &res) const
+    {
+        auto match = this->operator()(res);
 
-    if (match.nResidues() == 1)
-        return match(0);
-    else
-        return match;
-}
+        if (match.nResidues() == 1)
+            return match(0);
+        else
+            return match;
+    }
 
-/** Exposing MoleculeView::operator[] */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::operator[](const CGID &cg) const
-{
-    auto match = this->operator()(cg);
+    /** Exposing MoleculeView::operator[] */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::operator[](const CGID &cg) const
+    {
+        auto match = this->operator()(cg);
 
-    if (match.nCutGroups() == 1)
-        return match(0);
-    else
-        return match;
-}
+        if (match.nCutGroups() == 1)
+            return match(0);
+        else
+            return match;
+    }
 
-/** Exposing MoleculeView::operator[] */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::operator[](const ChainID &chain) const
-{
-    auto match = this->operator()(chain);
+    /** Exposing MoleculeView::operator[] */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::operator[](const ChainID &chain) const
+    {
+        auto match = this->operator()(chain);
 
-    if (match.nChains() == 1)
-        return match(0);
-    else
-        return match;
-}
+        if (match.nChains() == 1)
+            return match(0);
+        else
+            return match;
+    }
 
-/** Exposing MoleculeView::operator[] */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::operator[](const SegID &seg) const
-{
-    auto match = this->operator()(seg);
+    /** Exposing MoleculeView::operator[] */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::operator[](const SegID &seg) const
+    {
+        auto match = this->operator()(seg);
 
-    if (match.nSegments() == 1)
-        return match(0);
-    else
-        return match;
-}
+        if (match.nSegments() == 1)
+            return match(0);
+        else
+            return match;
+    }
 
-/** Exposing MoleculeView::operator[] */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::operator[](const SireID::Index &idx) const
-{
-    return this->operator()(idx.value());
-}
+    /** Exposing MoleculeView::operator[] */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::operator[](const SireID::Index &idx) const
+    {
+        return this->operator()(idx.value());
+    }
 
-/** Return the index of the ith view in this set (this supports negative indexing)
+    /** Return the index of the ith view in this set (this supports negative indexing)
 
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-typename T::Index Selector<T>::index(int i) const
-{
-    if (not this->isEmpty())
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        typename T::Index
+        Selector<T>::index(int i) const
     {
-        if (idxs.isEmpty())
-        {
-            const int n = detail::getCount<T>(this->data().info());
-            return typename T::Index(SireID::Index(i).map(n));
-        }
-        else
+        if (not this->isEmpty())
         {
-            return idxs.at( SireID::Index(i).map(idxs.count()));
+            if (idxs.isEmpty())
+            {
+                const int n = detail::getCount<T>(this->data().info());
+                return typename T::Index(SireID::Index(i).map(n));
+            }
+            else
+            {
+                return idxs.at(SireID::Index(i).map(idxs.count()));
+            }
         }
-    }
-
-    return typename T::Index(SireID::Index(i).map(0));
-}
 
-/** Return the ith view in this set (this supports negative indexing!)
+        return typename T::Index(SireID::Index(i).map(0));
+    }
 
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-T Selector<T>::operator()(int i) const
-{
-    return T(this->data(), this->index(i));
-}
+    /** Return the ith view in this set (this supports negative indexing!)
 
-/** Return the range of views from index i to j in this set. This
-    supports negative indexing, and also, if j is less then i, then
-    the order of views in the returned set is reversed
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        T
+        Selector<T>::operator()(int i) const
+    {
+        return T(this->data(), this->index(i));
+    }
 
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::operator()(int i, int j) const
-{
-    if (this->isEmpty())
-        // raise an index exception
-        i = SireID::Index(i).map(0);
+    /** Return the range of views from index i to j in this set. This
+        supports negative indexing, and also, if j is less then i, then
+        the order of views in the returned set is reversed
 
-    if (this->idxs.isEmpty())
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::operator()(int i, int j) const
     {
-        const int n = detail::getCount<T>(this->data().info());
+        if (this->isEmpty())
+            // raise an index exception
+            i = SireID::Index(i).map(0);
 
-        i = SireID::Index(i).map(n);
-        j = SireID::Index(j).map(n);
+        if (this->idxs.isEmpty())
+        {
+            const int n = detail::getCount<T>(this->data().info());
 
-        Selector<T> ret(*this);
-        ret.idxs.clear();
+            i = SireID::Index(i).map(n);
+            j = SireID::Index(j).map(n);
 
-        if (i <= j)
-        {
-            if (i == 0 and j == n-1)
-                // selected all
-                return ret;
+            Selector<T> ret(*this);
+            ret.idxs.clear();
 
-            for ( ; i<=j; ++i)
+            if (i <= j)
             {
-                ret.idxs.append(typename T::Index(i));
+                if (i == 0 and j == n - 1)
+                    // selected all
+                    return ret;
+
+                for (; i <= j; ++i)
+                {
+                    ret.idxs.append(typename T::Index(i));
+                }
+            }
+            else
+            {
+                if (i == n - 1 and j == 0)
+                    // selected all
+                    return ret;
+
+                for (; i >= j; --i)
+                {
+                    ret.idxs.append(typename T::Index(i));
+                }
             }
+
+            return ret;
         }
         else
         {
-            if (i == n-1 and j == 0)
-                // selected all
-                return ret;
+            i = SireID::Index(i).map(idxs.count());
+            j = SireID::Index(j).map(idxs.count());
+
+            Selector<T> ret(*this);
+            ret.idxs.clear();
 
-            for ( ; i >= j; --i)
+            if (i <= j)
             {
-                ret.idxs.append(typename T::Index(i));
+                for (; i <= j; ++i)
+                {
+                    ret.idxs.append(this->idxs.at(i));
+                }
+            }
+            else
+            {
+                for (; i >= j; --i)
+                {
+                    ret.idxs.append(this->idxs.at(i));
+                }
             }
-        }
 
-        return ret;
+            return ret;
+        }
     }
-    else
-    {
-        i = SireID::Index(i).map(idxs.count());
-        j = SireID::Index(j).map(idxs.count());
 
-        Selector<T> ret(*this);
-        ret.idxs.clear();
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::operator()(const SireBase::Slice &slice) const
+    {
+        if (this->isEmpty())
+            // raise an exception
+            slice.begin(0);
 
-        if (i <= j)
+        if (this->idxs.isEmpty())
         {
-            for ( ; i<=j; ++i)
+            const int n = detail::getCount<T>(this->data().info());
+
+            Selector<T> ret(*this);
+            ret.idxs.clear();
+
+            for (auto it = slice.begin(n); not it.atEnd(); it.next())
             {
-                ret.idxs.append(this->idxs.at(i));
+                ret.idxs.append(typename T::Index(it.value()));
             }
+
+            return ret;
         }
         else
         {
-            for ( ; i >= j; --i)
+            Selector<T> ret(*this);
+            ret.idxs.clear();
+
+            for (auto it = slice.begin(this->idxs.count());
+                 not it.atEnd(); it.next())
             {
-                ret.idxs.append(this->idxs.at(i));
+                ret.idxs.append(this->idxs.at(it.value()));
             }
-        }
 
-        return ret;
+            return ret;
+        }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::operator()(const SireBase::Slice &slice) const
-{
-    if (this->isEmpty())
-        //raise an exception
-        slice.begin(0);
+    /** Return the range of views from whose indicies are in idxs in this set.
 
-    if (this->idxs.isEmpty())
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::operator()(const QList<qint64> &idxs) const
     {
-        const int n = detail::getCount<T>(this->data().info());
-
-        Selector<T> ret(*this);
-        ret.idxs.clear();
+        if (idxs.isEmpty())
+            return Selector<T>();
 
-        for (auto it = slice.begin(n); not it.atEnd(); it.next())
+        else if (this->isEmpty())
         {
-            ret.idxs.append(typename T::Index(it.value()));
+            // raise an exception
+            SireID::Index(idxs.at(0)).map(0);
+            return Selector<T>();
         }
-
-        return ret;
-    }
-    else
-    {
-        Selector<T> ret(*this);
-        ret.idxs.clear();
-
-        for (auto it = slice.begin(this->idxs.count());
-             not it.atEnd(); it.next())
+        else if (this->idxs.isEmpty())
         {
-            ret.idxs.append(this->idxs.at(it.value()));
-        }
-
-        return ret;
-    }
-}
+            Selector<T> ret(*this);
+            ret.idxs.clear();
 
-/** Return the range of views from whose indicies are in idxs in this set.
+            const int n = detail::getCount<T>(this->data().info());
 
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::operator()(const QList<qint64> &idxs) const
-{
-    if (idxs.isEmpty())
-        return Selector<T>();
+            QSet<typename T::Index> seen;
 
-    else if (this->isEmpty())
-    {
-        //raise an exception
-        SireID::Index(idxs.at(0)).map(0);
-        return Selector<T>();
-    }
-    else if (this->idxs.isEmpty())
-    {
-        Selector<T> ret(*this);
-        ret.idxs.clear();
+            for (const auto &idx : idxs)
+            {
+                typename T::Index index(SireID::Index(idx).map(n));
 
-        const int n = detail::getCount<T>(this->data().info());
+                if (not seen.contains(index))
+                {
+                    ret.idxs.append(index);
+                    seen.insert(index);
+                }
+            }
 
-        QSet<typename T::Index> seen;
+            if (ret.idxs.count() >= n)
+                ret.idxs.clear();
 
-        for (const auto &idx : idxs)
+            return ret;
+        }
+        else
         {
-            typename T::Index index(SireID::Index(idx).map(n));
+            Selector<T> ret(*this);
+            ret.idxs.clear();
 
-            if (not seen.contains(index))
+            for (const auto &idx : idxs)
             {
+                auto index = this->idxs.at(SireID::Index(idx).map(this->idxs.count()));
                 ret.idxs.append(index);
-                seen.insert(index);
             }
-        }
-
-        if (ret.idxs.count() >= n)
-            ret.idxs.clear();
-
-        return ret;
-    }
-    else
-    {
-        Selector<T> ret(*this);
-        ret.idxs.clear();
 
-        for (const auto &idx : idxs)
-        {
-            auto index = this->idxs.at(SireID::Index(idx).map(this->idxs.count()));
-            ret.idxs.append(index);
+            return ret;
         }
-
-        return ret;
     }
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<Atom> Selector<T>::operator()(const AtomID &atomid) const
-{
-    return this->atoms(atomid);
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<Residue> Selector<T>::operator()(const ResID &resid) const
-{
-    return this->residues(resid);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<Atom>
+        Selector<T>::operator()(const AtomID &atomid) const
+    {
+        return this->atoms(atomid);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<CutGroup> Selector<T>::operator()(const CGID &cgid) const
-{
-    return this->cutGroups(cgid);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<Residue>
+        Selector<T>::operator()(const ResID &resid) const
+    {
+        return this->residues(resid);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<Chain> Selector<T>::operator()(const ChainID &chainid) const
-{
-    return this->chains(chainid);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<CutGroup>
+        Selector<T>::operator()(const CGID &cgid) const
+    {
+        return this->cutGroups(cgid);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<Segment> Selector<T>::operator()(const SegID &segid) const
-{
-    return this->segments(segid);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<Chain>
+        Selector<T>::operator()(const ChainID &chainid) const
+    {
+        return this->chains(chainid);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MolViewPtr Selector<T>::toSelector() const
-{
-    return MolViewPtr(*this);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<Segment>
+        Selector<T>::operator()(const SegID &segid) const
+    {
+        return this->segments(segid);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Molecules Selector<T>::toMolecules() const
-{
-    return Molecules( ViewsOfMol(*this) );
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MolViewPtr
+        Selector<T>::toSelector() const
+    {
+        return MolViewPtr(*this);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QList<MolViewPtr> Selector<T>::toList() const
-{
-    QList<MolViewPtr> l;
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Molecules
+        Selector<T>::toMolecules() const
+    {
+        return Molecules(ViewsOfMol(*this));
+    }
 
-    if (not this->isEmpty())
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<MolViewPtr>
+        Selector<T>::toList() const
     {
-        if (idxs.isEmpty())
+        QList<MolViewPtr> l;
+
+        if (not this->isEmpty())
         {
-            //return the entire molecule
-            const auto& d = this->data();
+            if (idxs.isEmpty())
+            {
+                // return the entire molecule
+                const auto &d = this->data();
 
-            const int n = detail::getCount<T>(d.info());
-            l.reserve(n);
+                const int n = detail::getCount<T>(d.info());
+                l.reserve(n);
 
-            for (int i=0; i<n; ++i)
-            {
-                l.append(MolViewPtr(new T(d, typename T::Index(i))));
+                for (int i = 0; i < n; ++i)
+                {
+                    l.append(MolViewPtr(new T(d, typename T::Index(i))));
+                }
             }
-        }
-        else
-        {
-            //return the selected part of the molecule
-            l.reserve(idxs.count());
+            else
+            {
+                // return the selected part of the molecule
+                l.reserve(idxs.count());
 
-            const auto& d = this->data();
+                const auto &d = this->data();
 
-            for (const auto &idx : idxs)
-            {
-                l.append(MolViewPtr(new T(d, idx)));
+                for (const auto &idx : idxs)
+                {
+                    l.append(MolViewPtr(new T(d, idx)));
+                }
             }
         }
+
+        return l;
     }
 
-    return l;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        T
+        Selector<T>::operator()(const SireID::Index &idx) const
+    {
+        return this->operator()(idx.value());
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-T Selector<T>::operator()(const SireID::Index &idx) const
-{
-    return this->operator()(idx.value());
-}
-
-/** Return the number of views in this set */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int Selector<T>::nViews() const
-{
-    if (this->isEmpty())
-        return 0;
-    else if (this->selectedAll())
-        return detail::getCount<T>(this->data().info());
-    else
-        return this->idxs.count();
-}
+    /** Return the number of views in this set */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int Selector<T>::nViews() const
+    {
+        if (this->isEmpty())
+            return 0;
+        else if (this->selectedAll())
+            return detail::getCount<T>(this->data().info());
+        else
+            return this->idxs.count();
+    }
 
-template<class T>
-SIRE_INLINE_TEMPLATE
-QSet<T> _list_to_set(const QList<T> &vals)
-{
-    #if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    template <class T>
+    SIRE_INLINE_TEMPLATE
+        QSet<T>
+        _list_to_set(const QList<T> &vals)
+    {
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
         return QSet<T>(vals.constBegin(), vals.constEnd());
-    #else
+#else
         return vals.toSet();
-    #endif
-}
+#endif
+    }
 
-/** Return the intersection of this set with 'other' - the
-    views in both sets are returned, in the order that they
-    appear in this set
+    /** Return the intersection of this set with 'other' - the
+        views in both sets are returned, in the order that they
+        appear in this set
 
-    \throw SireError::incompatible_error
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::intersection(const Selector<T> &other) const
-{
-    if (this->isEmpty() or other.isEmpty())
-        return Selector<T>();
-
-    else if (this->selectedAll())
+        \throw SireError::incompatible_error
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::intersection(const Selector<T> &other) const
     {
-        MoleculeView::assertSameMolecule(other);
-        Selector<T> ret(*this);
-        ret.idxs = other.idxs;
-        return ret;
+        if (this->isEmpty() or other.isEmpty())
+            return Selector<T>();
+
+        else if (this->selectedAll())
+        {
+            MoleculeView::assertSameMolecule(other);
+            Selector<T> ret(*this);
+            ret.idxs = other.idxs;
+            return ret;
+        }
+        else if (other.selectedAll())
+        {
+            MoleculeView::assertSameMolecule(other);
+            return *this;
+        }
+        else
+        {
+            MoleculeView::assertSameMolecule(other);
+
+            Selector<T> ret(*this);
+            ret.idxs.clear();
+
+            auto this_idxs = this->idxs;
+            auto other_idxs = other.idxs;
+
+            const int n = detail::getCount<T>(this->data().info());
+
+            if (this_idxs.isEmpty())
+            {
+                this_idxs.reserve(n);
+                for (int i = 0; i < n; ++i)
+                {
+                    this_idxs.append(typename T::Index(i));
+                }
+            }
+
+            if (other_idxs.isEmpty())
+            {
+                other_idxs.reserve(n);
+                for (int i = 0; i < n; ++i)
+                {
+                    other_idxs.append(typename T::Index(i));
+                }
+            }
+
+            auto seen = _list_to_set(other_idxs);
+
+            for (const auto &idx : this_idxs)
+            {
+                if (seen.contains(idx))
+                    ret.idxs.append(idx);
+            }
+
+            if (ret.idxs.isEmpty())
+            {
+                return Selector<T>();
+            }
+
+            return ret;
+        }
     }
-    else if (other.selectedAll())
+
+    /** Return the intersection of this set with 'view'
+
+        \throw SireError::incompatible_error
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::intersection(const T &view) const
     {
-        MoleculeView::assertSameMolecule(other);
-        return *this;
+        return this->intersection(Selector<T>(view));
     }
-    else
-    {
-        MoleculeView::assertSameMolecule(other);
 
-        Selector<T> ret(*this);
-        ret.idxs.clear();
+    /** Return the intersection of this set with the views identified
+        by the ID 'id'
 
-        auto this_idxs = this->idxs;
-        auto other_idxs = other.idxs;
+        \throw SireMol::missing_atom
+        \throw SireMol::missing_residue
+        \throw SireMol::missing_chain
+        \throw SireMol::missing_segment
+        \throw SireMol::missing_cutgroup
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::intersection(const typename T::ID &id) const
+    {
+        return this->intersection(Selector<T>(this->data(), id));
+    }
 
-        const int n = detail::getCount<T>(this->data().info());
+    /** Return the index in this collection of the view that
+     *  matches 'view'. This returns an empty list if the
+     *  view is not in this collection
+     */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<qint64>
+        Selector<T>::find(const T &view) const
+    {
+        QList<qint64> matches;
 
-        if (this_idxs.isEmpty())
+        if (MoleculeView::isSameMolecule(view))
         {
-            this_idxs.reserve(n);
-            for (int i=0; i<n; ++i)
+            if (this->selectedAll())
+            {
+                matches.append(view.index().value());
+            }
+            else if (not this->isEmpty())
             {
-                this_idxs.append(typename T::Index(i));
+                int match = this->idxs.indexOf(view.index());
+
+                if (match != -1)
+                    matches.append(match);
             }
         }
 
-        if (other_idxs.isEmpty())
+        return matches;
+    }
+
+    /** Return the index in this collection of any views that
+     *  matches 'views'. This returns an empty list if none of
+     *  the views are in this collection
+     */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<qint64>
+        Selector<T>::find(const Selector<T> &views) const
+    {
+        QList<qint64> matches;
+
+        if (MoleculeView::isSameMolecule(views))
         {
-            other_idxs.reserve(n);
-            for (int i=0; i<n; ++i)
+            if (this->selectedAll())
+            {
+                if (views.selectedAll())
+                {
+                    for (int i = 0; i < this->count(); ++i)
+                    {
+                        matches.append(i);
+                    }
+                }
+                else if (not views.isEmpty())
+                {
+                    for (const auto &idx : views.idxs)
+                    {
+                        matches.append(idx.value());
+                    }
+                }
+            }
+            else if (not this->isEmpty())
             {
-                other_idxs.append(typename T::Index(i));
+                if (views.selectedAll())
+                {
+                    for (int i = 0; i < this->count(); ++i)
+                    {
+                        matches.append(i);
+                    }
+                }
+                else if (not views.isEmpty())
+                {
+                    for (const auto &idx : views.idxs)
+                    {
+                        int match = this->idxs.indexOf(idx);
+
+                        if (match != -1)
+                            matches.append(match);
+                    }
+                }
             }
         }
 
-        auto seen = _list_to_set(other_idxs);
+        return matches;
+    }
 
-        for (const auto &idx : this_idxs)
+    /** Return the set that has a completely inverted selection */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::invert() const
+    {
+        if (this->isEmpty())
         {
-            if (seen.contains(idx))
-                ret.idxs.append(idx);
+            throw SireMol::missing_atom(QObject::tr(
+                                            "Cannot invert an empty selection!"),
+                                        CODELOC);
         }
-
-        if (ret.idxs.isEmpty())
+        else if (this->selectedAll())
         {
             return Selector<T>();
         }
+        else
+        {
+            Selector<T> ret(*this);
+            ret.idxs.clear();
 
-        return ret;
-    }
-}
+            const int n = detail::getCount<T>(this->data().info());
 
-/** Return the intersection of this set with 'view'
+            if (this->idxs.count() == 1)
+            {
+                auto seen = this->idxs.at(0);
 
-    \throw SireError::incompatible_error
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::intersection(const T &view) const
-{
-    return this->intersection(Selector<T>(view));
-}
+                for (int i = 0; i < n; ++i)
+                {
+                    typename T::Index idx(i);
 
-/** Return the intersection of this set with the views identified
-    by the ID 'id'
-
-    \throw SireMol::missing_atom
-    \throw SireMol::missing_residue
-    \throw SireMol::missing_chain
-    \throw SireMol::missing_segment
-    \throw SireMol::missing_cutgroup
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::intersection(const typename T::ID &id) const
-{
-    return this->intersection(Selector<T>(this->data(), id));
-}
+                    if (idx != seen)
+                        ret.idxs.append(idx);
+                }
+            }
+            else
+            {
+                auto seen = _list_to_set(this->idxs);
 
-/** Return the set that has a completely inverted selection */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::invert() const
-{
-    if (this->isEmpty())
-    {
-        throw SireMol::missing_atom(QObject::tr(
-            "Cannot invert an empty selection!"), CODELOC);
-    }
-    else if (this->selectedAll())
-    {
-        return Selector<T>();
+                for (int i = 0; i < n; ++i)
+                {
+                    typename T::Index idx(i);
+
+                    if (not seen.contains(idx))
+                        ret.idxs.append(idx);
+                }
+            }
+
+            return ret;
+        }
     }
-    else
-    {
-        Selector<T> ret(*this);
-        ret.idxs.clear();
 
-        const int n = detail::getCount<T>(this->data().info());
+    /** Return whether this set contains all of the views
+        in 'other' */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::contains(const Selector<T> &other) const
+    {
+        if (this->isEmpty() or other.isEmpty())
+            return false;
 
-        if (this->idxs.count() == 1)
-        {
-            auto seen = this->idxs.at(0);
+        MoleculeView::assertSameMolecule(other);
 
-            for (int i=0; i<n; ++i)
-            {
-                typename T::Index idx(i);
+        if (this->selectedAll())
+            return true;
+        else if (other.selectedAll())
+            return false;
 
-                if (idx != seen)
-                    ret.idxs.append(idx);
-            }
-        }
         else
         {
             auto seen = _list_to_set(this->idxs);
 
-            for (int i=0; i<n; ++i)
+            for (const auto &idx : other.idxs)
             {
-                typename T::Index idx(i);
-
                 if (not seen.contains(idx))
-                    ret.idxs.append(idx);
+                    return false;
             }
-        }
 
-        return ret;
+            return true;
+        }
     }
-}
 
-/** Return whether this set contains all of the views
-    in 'other' */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::contains(const Selector<T> &other) const
-{
-    if (this->isEmpty() or other.isEmpty())
-        return false;
+    /** Return whether this set contains some of the view
+        in other
 
-    MoleculeView::assertSameMolecule(other);
+        \throw SireError::incompatible_error
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::intersects(const Selector<T> &other) const
+    {
+        if (this->isEmpty() or other.isEmpty())
+            return false;
 
-    if (this->selectedAll())
-        return true;
-    else if (other.selectedAll())
-        return false;
+        MoleculeView::assertSameMolecule(other);
+
+        if (this->selectedAll() or other.selectedAll())
+            return true;
 
-    else
-    {
         auto seen = _list_to_set(this->idxs);
 
         for (const auto &idx : other.idxs)
         {
-            if (not seen.contains(idx))
-                return false;
+            if (seen.contains(idx))
+                return true;
         }
 
-        return true;
-    }
-}
-
-/** Return whether this set contains some of the view
-    in other
-
-    \throw SireError::incompatible_error
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::intersects(const Selector<T> &other) const
-{
-    if (this->isEmpty() or other.isEmpty())
         return false;
+    }
 
-    MoleculeView::assertSameMolecule(other);
-
-    if (this->selectedAll() or other.selectedAll())
-        return true;
+    /** Return whether or not this set contains the view 'view' */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::contains(const T &view) const
+    {
+        return this->contains(Selector<T>(view));
+    }
 
-    auto seen = _list_to_set(this->idxs);
+    /** Return whether or not this set contains all of the
+        view identified by the ID 'id' */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::contains(const typename T::ID &id) const
+    {
+        return this->contains(Selector<T>(this->data(), id));
+    }
 
-    for (const auto &idx : other.idxs)
+    /** Return whether or not this set contains the view 'view' */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::intersects(const T &view) const
     {
-        if (seen.contains(idx))
-            return true;
+        return this->intersects(Selector<T>(view));
     }
 
-    return false;
-}
+    /** Return whether this set contains some of the views
+        identified by the ID 'id' */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::intersects(const typename T::ID &id) const
+    {
+        return this->intersects(Selector<T>(this->data(), id));
+    }
 
-/** Return whether or not this set contains the view 'view' */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::contains(const T &view) const
-{
-    return this->contains(Selector<T>(view));
-}
+    /** Return all of the atoms selected in this set */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        AtomSelection
+        Selector<T>::selection() const
+    {
+        if (this->isEmpty())
+            return AtomSelection();
 
-/** Return whether or not this set contains all of the
-    view identified by the ID 'id' */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::contains(const typename T::ID &id) const
-{
-    return this->contains(Selector<T>(this->data(), id));
-}
+        else if (this->selectedAll())
+        {
+            return AtomSelection(this->data());
+        }
 
-/** Return whether or not this set contains the view 'view' */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::intersects(const T &view) const
-{
-    return this->intersects(Selector<T>(view));
-}
+        AtomSelection selected_atoms(this->data());
 
-/** Return whether this set contains some of the views
-    identified by the ID 'id' */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::intersects(const typename T::ID &id) const
-{
-    return this->intersects(Selector<T>(this->data(), id));
-}
+        selected_atoms.selectNone();
 
-/** Return all of the atoms selected in this set */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-AtomSelection Selector<T>::selection() const
-{
-    if (this->isEmpty())
-        return AtomSelection();
+        for (const auto &idx : this->idxs)
+        {
+            selected_atoms.select(idx);
+        }
 
-    else if (this->selectedAll())
-    {
-        return AtomSelection(this->data());
+        return selected_atoms;
     }
 
-    AtomSelection selected_atoms(this->data());
+    /** Return the selection of the atoms in the ith view
 
-    selected_atoms.selectNone();
-
-    for (const auto &idx : this->idxs)
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        AtomSelection
+        Selector<T>::selection(int i) const
     {
-        selected_atoms.select(idx);
+        return this->operator()(i).selection();
     }
 
-    return selected_atoms;
-}
-
-/** Return the selection of the atoms in the ith view
-
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-AtomSelection Selector<T>::selection(int i) const
-{
-    return this->operator()(i).selection();
-}
+    /** Return the selection of the atoms in the ith to jth views
 
-/** Return the selection of the atoms in the ith to jth views
-
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-AtomSelection Selector<T>::selection(int i, int j) const
-{
-    return this->operator()(i, j).selection();
-}
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        AtomSelection
+        Selector<T>::selection(int i, int j) const
+    {
+        return this->operator()(i, j).selection();
+    }
 
-/** Return an object that can move a copy of all of the views
-    in this set */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Mover< Selector<T> > Selector<T>::move() const
-{
-    return Mover< Selector<T> >(*this);
-}
+    /** Return an object that can move a copy of all of the views
+        in this set */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Mover<Selector<T>>
+        Selector<T>::move() const
+    {
+        return Mover<Selector<T>>(*this);
+    }
 
-/** Return an object that can move the ith view in this set */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Mover< Selector<T> > Selector<T>::move(int i) const
-{
-    return Mover< Selector<T> >(Selector<T>(this->operator()(i)));
-}
+    /** Return an object that can move the ith view in this set */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Mover<Selector<T>>
+        Selector<T>::move(int i) const
+    {
+        return Mover<Selector<T>>(Selector<T>(this->operator()(i)));
+    }
 
-/** Return an object that can move the ith to jth views in this set */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Mover< Selector<T> > Selector<T>::move(int i, int j) const
-{
-    return Mover< Selector<T> >(this->operator()(i,j));
-}
+    /** Return an object that can move the ith to jth views in this set */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Mover<Selector<T>>
+        Selector<T>::move(int i, int j) const
+    {
+        return Mover<Selector<T>>(this->operator()(i, j));
+    }
 
-/** Return an evaluator that can evaluate properties over all
-    of the views in this set */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Evaluator Selector<T>::evaluate() const
-{
-    return Evaluator(*this);
-}
+    /** Return an evaluator that can evaluate properties over all
+        of the views in this set */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Evaluator
+        Selector<T>::evaluate() const
+    {
+        return Evaluator(*this);
+    }
 
-/** Return an evaluator that can evaluate properties over the
-    ith view in this set */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Evaluator Selector<T>::evaluate(int i) const
-{
-    return Evaluator(this->operator()(i));
-}
+    /** Return an evaluator that can evaluate properties over the
+        ith view in this set */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Evaluator
+        Selector<T>::evaluate(int i) const
+    {
+        return Evaluator(this->operator()(i));
+    }
 
-/** Return an evaluator that can evaluate properties over
-    the ith to jth views in this set */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Evaluator Selector<T>::evaluate(int i, int j) const
-{
-    return Evaluator(this->operator()(i,j));
-}
+    /** Return an evaluator that can evaluate properties over
+        the ith to jth views in this set */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Evaluator
+        Selector<T>::evaluate(int i, int j) const
+    {
+        return Evaluator(this->operator()(i, j));
+    }
 
-/** Return a selector that can change the selection of this view */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::selector() const
-{
-    return *this;
-}
+    /** Return a selector that can change the selection of this view */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::selector() const
+    {
+        return *this;
+    }
 
-/** Return a selector for the ith view that can change the
-    selection of that view
+    /** Return a selector for the ith view that can change the
+        selection of that view
 
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::selector(int i) const
-{
-    return Selector<T>(this->operator()(i));
-}
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::selector(int i) const
+    {
+        return Selector<T>(this->operator()(i));
+    }
 
-/** Return a selector for the ith to jth views
+    /** Return a selector for the ith to jth views
 
-    \throw SireError::invalid_index
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Selector<T> Selector<T>::selector(int i, int j) const
-{
-    return this->operator()(i, j);
-}
+        \throw SireError::invalid_index
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Selector<T>
+        Selector<T>::selector(int i, int j) const
+    {
+        return this->operator()(i, j);
+    }
 
-/** Return a list of the values of the property called 'key' for each
-    of the views in this set, in the order that they appear in this set.
+    /** Return a list of the values of the property called 'key' for each
+        of the views in this set, in the order that they appear in this set.
 
-    \throw SireBase::missing_property
-    \throw SireError::invalid_cast
-*/
-template<class T>
-template<class V>
-SIRE_OUTOFLINE_TEMPLATE
-QList<V> Selector<T>::property(const PropertyName &key) const
-{
-    T *ptr = 0;
-    return detail::get_property<V>(ptr, this->data(), this->IDs(), key);
-}
+        \throw SireBase::missing_property
+        \throw SireError::invalid_cast
+    */
+    template <class T>
+    template <class V>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<V>
+        Selector<T>::property(const PropertyName &key) const
+    {
+        T *ptr = 0;
+        return detail::get_property<V>(ptr, this->data(), this->IDs(), key);
+    }
 
-/** Return a list of all of the metadata called 'metakey' for each
-    of the views in this set, in the order they appear in this set.
+    /** Return a list of all of the metadata called 'metakey' for each
+        of the views in this set, in the order they appear in this set.
 
-    \throw SireBase::missing_property
-    \throw SireError::invalid_cast
-*/
-template<class T>
-template<class V>
-SIRE_OUTOFLINE_TEMPLATE
-QList<V> Selector<T>::metadata(const PropertyName &metakey) const
-{
-    T *ptr = 0;
-    return detail::get_metadata<V>(ptr, this->data(),
-                                   this->IDs(), metakey);
-}
+        \throw SireBase::missing_property
+        \throw SireError::invalid_cast
+    */
+    template <class T>
+    template <class V>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<V>
+        Selector<T>::metadata(const PropertyName &metakey) const
+    {
+        T *ptr = 0;
+        return detail::get_metadata<V>(ptr, this->data(),
+                                       this->IDs(), metakey);
+    }
 
-/** Return a list of all of the metadata called 'key'/'metakey' for each
-    of the views in this set, in the order they appear in this set.
+    /** Return a list of all of the metadata called 'key'/'metakey' for each
+        of the views in this set, in the order they appear in this set.
 
-    \throw SireBase::missing_property
-    \throw SireError::invalid_cast
-*/
-template<class T>
-template<class V>
-SIRE_OUTOFLINE_TEMPLATE
-QList<V> Selector<T>::metadata(const PropertyName &key,
-                               const PropertyName &metakey) const
-{
-    T *ptr = 0;
-    return detail::get_metadata<V>(ptr, this->data(), this->IDs(),
-                                   key, metakey);
-}
+        \throw SireBase::missing_property
+        \throw SireError::invalid_cast
+    */
+    template <class T>
+    template <class V>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<V>
+        Selector<T>::metadata(const PropertyName &key,
+                              const PropertyName &metakey) const
+    {
+        T *ptr = 0;
+        return detail::get_metadata<V>(ptr, this->data(), this->IDs(),
+                                       key, metakey);
+    }
 
-/** Set the property at key 'key' for all of the views in this set
-    to the values in 'values', with the values given in the same
-    order as the views in this set.
+    /** Set the property at key 'key' for all of the views in this set
+        to the values in 'values', with the values given in the same
+        order as the views in this set.
 
-    \throw SireError::incompatible_error
-    \throw SireError::invalid_cast
-*/
-template<class T>
-template<class V>
-SIRE_OUTOFLINE_TEMPLATE
-void Selector<T>::setProperty(const QString &key, const QList<V> &values)
-{
-    T *ptr = 0;
-    detail::set_property<V>(ptr, this->data(), this->IDs(), key, values);
-}
-
-/** Set the metadata at key 'metakey' for all of the views in this set
-    to the values in 'values', with the values given in the same
-    order as the views in this set.
+        \throw SireError::incompatible_error
+        \throw SireError::invalid_cast
+    */
+    template <class T>
+    template <class V>
+    SIRE_OUTOFLINE_TEMPLATE void Selector<T>::setProperty(const QString &key, const QList<V> &values)
+    {
+        T *ptr = 0;
+        detail::set_property<V>(ptr, this->data(), this->IDs(), key, values);
+    }
 
-    \throw SireError::incompatible_error
-    \throw SireError::invalid_cast
-*/
-template<class T>
-template<class V>
-SIRE_OUTOFLINE_TEMPLATE
-void Selector<T>::setMetadata(const QString &metakey, const QList<V> &values)
-{
-    T *ptr = 0;
-    detail::set_metadata<V>(ptr, this->data(), this->IDs(), metakey, values);
-}
+    /** Set the metadata at key 'metakey' for all of the views in this set
+        to the values in 'values', with the values given in the same
+        order as the views in this set.
 
+        \throw SireError::incompatible_error
+        \throw SireError::invalid_cast
+    */
+    template <class T>
+    template <class V>
+    SIRE_OUTOFLINE_TEMPLATE void Selector<T>::setMetadata(const QString &metakey, const QList<V> &values)
+    {
+        T *ptr = 0;
+        detail::set_metadata<V>(ptr, this->data(), this->IDs(), metakey, values);
+    }
 
-/** Set the metadata at key 'key'/'metakey' for all of the views in this set
-    to the values in 'values', with the values given in the same
-    order as the views in this set.
+    /** Set the metadata at key 'key'/'metakey' for all of the views in this set
+        to the values in 'values', with the values given in the same
+        order as the views in this set.
 
-    \throw SireError::incompatible_error
-    \throw SireError::invalid_cast
-*/
-template<class T>
-template<class V>
-SIRE_OUTOFLINE_TEMPLATE
-void Selector<T>::setMetadata(const QString &key, const QString &metakey,
-                              const QList<V> &values)
-{
-    T *ptr = 0;
-    detail::set_metadata<V>(ptr, this->data(), this->IDs(), key, metakey, values);
-}
+        \throw SireError::incompatible_error
+        \throw SireError::invalid_cast
+    */
+    template <class T>
+    template <class V>
+    SIRE_OUTOFLINE_TEMPLATE void Selector<T>::setMetadata(const QString &key, const QString &metakey,
+                                                          const QList<V> &values)
+    {
+        T *ptr = 0;
+        detail::set_metadata<V>(ptr, this->data(), this->IDs(), key, metakey, values);
+    }
 
-/** Set the property at key 'key' for all of the views in this set
-    to the value 'value'
+    /** Set the property at key 'key' for all of the views in this set
+        to the value 'value'
 
-    \throw SireError::invalid_cast
-*/
-template<class T>
-template<class V>
-SIRE_OUTOFLINE_TEMPLATE
-void Selector<T>::setProperty(const QString &key, const V &value)
-{
-    T *ptr = 0;
-    detail::set_property<V>(ptr, this->data(), this->IDs(), key, value);
-}
+        \throw SireError::invalid_cast
+    */
+    template <class T>
+    template <class V>
+    SIRE_OUTOFLINE_TEMPLATE void Selector<T>::setProperty(const QString &key, const V &value)
+    {
+        T *ptr = 0;
+        detail::set_property<V>(ptr, this->data(), this->IDs(), key, value);
+    }
 
-/** Set the metadata at metakey 'metakey' for all of the views in this set
-    to the value 'value'
+    /** Set the metadata at metakey 'metakey' for all of the views in this set
+        to the value 'value'
 
-    \throw SireError::invalid_cast
-*/
-template<class T>
-template<class V>
-SIRE_OUTOFLINE_TEMPLATE
-void Selector<T>::setMetadata(const QString &metakey, V &value)
-{
-    T *ptr = 0;
-    detail::set_metadata<V>(ptr, this->data(), this->IDs(), metakey, value);
-}
+        \throw SireError::invalid_cast
+    */
+    template <class T>
+    template <class V>
+    SIRE_OUTOFLINE_TEMPLATE void Selector<T>::setMetadata(const QString &metakey, V &value)
+    {
+        T *ptr = 0;
+        detail::set_metadata<V>(ptr, this->data(), this->IDs(), metakey, value);
+    }
 
-/** Set the metadata at key 'key'/'metakey' for all of the views in this set
-    to the value 'value'
+    /** Set the metadata at key 'key'/'metakey' for all of the views in this set
+        to the value 'value'
 
-    \throw SireError::invalid_cast
-*/
-template<class T>
-template<class V>
-SIRE_OUTOFLINE_TEMPLATE
-void Selector<T>::setMetadata(const QString &key, const QString &metakey,
-                              const V &value)
-{
-    T *ptr = 0;
-    detail::set_metadata<V>(ptr, this->data(), this->IDs(), key, metakey, value);
-}
+        \throw SireError::invalid_cast
+    */
+    template <class T>
+    template <class V>
+    SIRE_OUTOFLINE_TEMPLATE void Selector<T>::setMetadata(const QString &key, const QString &metakey,
+                                                          const V &value)
+    {
+        T *ptr = 0;
+        detail::set_metadata<V>(ptr, this->data(), this->IDs(), key, metakey, value);
+    }
 
-/** Return whether or not the views of this selector has a property
-    at key 'key' */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::hasProperty(const PropertyName &key) const
-{
-    T *ptr = 0;
-    return detail::has_property(ptr, this->data(), key);
-}
+    /** Return whether or not the views of this selector has a property
+        at key 'key' */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::hasProperty(const PropertyName &key) const
+    {
+        T *ptr = 0;
+        return detail::has_property(ptr, this->data(), key);
+    }
 
-/** Return whether or not the views of this selector have metadata
-    at metakey 'metakey' */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::hasMetadata(const PropertyName &metakey) const
-{
-    T *ptr = 0;
-    return detail::has_metadata(ptr, this->data(), metakey);
-}
+    /** Return whether or not the views of this selector have metadata
+        at metakey 'metakey' */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::hasMetadata(const PropertyName &metakey) const
+    {
+        T *ptr = 0;
+        return detail::has_metadata(ptr, this->data(), metakey);
+    }
 
-/** Return whether or not the property at key 'key' for the views
-    of this selector has metadata at metakey 'metakey'
+    /** Return whether or not the property at key 'key' for the views
+        of this selector has metadata at metakey 'metakey'
 
-    \throw SireBase::missing_property
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool Selector<T>::hasMetadata(const PropertyName &key,
-                              const PropertyName &metakey) const
-{
-    T *ptr = 0;
-    return detail::has_metadata(ptr, this->data(), key, metakey);
-}
+        \throw SireBase::missing_property
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool Selector<T>::hasMetadata(const PropertyName &key,
+                                                          const PropertyName &metakey) const
+    {
+        T *ptr = 0;
+        return detail::has_metadata(ptr, this->data(), key, metakey);
+    }
 
-/** Return all of the keys for the properties attached to the
-    parts of this selection */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QStringList Selector<T>::propertyKeys() const
-{
-    if (this->isEmpty())
-        return QStringList();
-    else
-        return this->operator()(0).propertyKeys();
-}
+    /** Return all of the keys for the properties attached to the
+        parts of this selection */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QStringList
+        Selector<T>::propertyKeys() const
+    {
+        if (this->isEmpty())
+            return QStringList();
+        else
+            return this->operator()(0).propertyKeys();
+    }
 
-/** Return all of the metakeys for the metadata attached to the
-    parts of this selection */
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QStringList Selector<T>::metadataKeys() const
-{
-    if (this->isEmpty())
-        return QStringList();
-    else
-        return this->operator()(0).metadataKeys();
-}
+    /** Return all of the metakeys for the metadata attached to the
+        parts of this selection */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QStringList
+        Selector<T>::metadataKeys() const
+    {
+        if (this->isEmpty())
+            return QStringList();
+        else
+            return this->operator()(0).metadataKeys();
+    }
 
-/** Return all of the metakeys for the metadata attached to the
-    parts of this selection for the property at key 'key'
+    /** Return all of the metakeys for the metadata attached to the
+        parts of this selection for the property at key 'key'
 
-    \throw SireBase::missing_property
-*/
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QStringList Selector<T>::metadataKeys(const PropertyName &key) const
-{
-    if (this->isEmpty())
-        return QStringList();
-    else
-        return this->operator()(0).metadataKeys(key);
-}
+        \throw SireBase::missing_property
+    */
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QStringList
+        Selector<T>::metadataKeys(const PropertyName &key) const
+    {
+        if (this->isEmpty())
+            return QStringList();
+        else
+            return this->operator()(0).metadataKeys(key);
+    }
 
-#endif //SIRE_SKIP_INLINE_FUNCTIONS
+#endif // SIRE_SKIP_INLINE_FUNCTIONS
 
 } // end of namespace SireMol
 
 #ifndef SIRE_SKIP_INLINE_FUNCTIONS
 
 /** Extract from a binary datastream */
-template<class T>
+template <class T>
 SIRE_OUTOFLINE_TEMPLATE
-SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SireMol::Selector<T> &views)
+    SIREMOL_EXPORT QDataStream &
+    operator>>(QDataStream &ds, SireMol::Selector<T> &views)
 {
     QString cls;
     SireStream::VersionID version;
@@ -1862,8 +2004,10 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SireMol::Selector<T> &vi
     if (cls != QString(SireMol::Selector<T>::typeName()))
     {
         throw SireStream::corrupted_data(QObject::tr(
-            "Found the wrong class (%1) when trying to read a %2.")
-                .arg(cls).arg(SireMol::Selector<T>::typeName()), CODELOC);
+                                             "Found the wrong class (%1) when trying to read a %2.")
+                                             .arg(cls)
+                                             .arg(SireMol::Selector<T>::typeName()),
+                                         CODELOC);
     }
 
     ds >> version;
@@ -1871,7 +2015,7 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SireMol::Selector<T> &vi
     if (version == 2)
     {
         SireStream::SharedDataStream sds(ds);
-        sds >> views.idxs >> static_cast<SireMol::MoleculeView&>(views);
+        sds >> views.idxs >> static_cast<SireMol::MoleculeView &>(views);
     }
     else if (version == 1)
     {
@@ -1894,15 +2038,16 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SireMol::Selector<T> &vi
 }
 
 /** Serialise to a binary datastream */
-template<class T>
+template <class T>
 SIRE_OUTOFLINE_TEMPLATE
-SIREMOL_EXPORT QDataStream &operator<<(QDataStream &ds, const SireMol::Selector<T> &views)
+    SIREMOL_EXPORT QDataStream &
+    operator<<(QDataStream &ds, const SireMol::Selector<T> &views)
 {
     ds << QString(SireMol::Selector<T>::typeName()) << SireStream::VersionID(2);
 
     SireStream::SharedDataStream sds(ds);
 
-    sds << views.idxs << static_cast<const SireMol::MoleculeView&>(views);
+    sds << views.idxs << static_cast<const SireMol::MoleculeView &>(views);
 
     return ds;
 }
diff --git a/corelib/src/libs/SireMol/selectorm.hpp b/corelib/src/libs/SireMol/selectorm.hpp
index fc88ca39b..82c137c18 100644
--- a/corelib/src/libs/SireMol/selectorm.hpp
+++ b/corelib/src/libs/SireMol/selectorm.hpp
@@ -41,2450 +41,2630 @@ SIRE_BEGIN_HEADER
 
 namespace SireMol
 {
-template<class T>
-class SelectorM;
+    template <class T>
+    class SelectorM;
 
-class SelectorMol;
+    class SelectorMol;
 }
 
-template<class T>
-SIREMOL_EXPORT QDataStream& operator<<(QDataStream&, const SireMol::SelectorM<T>&);
+template <class T>
+SIREMOL_EXPORT QDataStream &operator<<(QDataStream &, const SireMol::SelectorM<T> &);
 
-template<class T>
-SIREMOL_EXPORT QDataStream& operator>>(QDataStream&, SireMol::SelectorM<T>&);
+template <class T>
+SIREMOL_EXPORT QDataStream &operator>>(QDataStream &, SireMol::SelectorM<T> &);
 
 namespace SireMol
 {
 
-/** This is an analogue of the Selector<T> class that is designed
-    to hold views from multiple molecules
-*/
-template<class T>
-class SIREMOL_EXPORT SelectorM
-    : public SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>
-{
+    /** This is an analogue of the Selector<T> class that is designed
+        to hold views from multiple molecules
+    */
+    template <class T>
+    class SIREMOL_EXPORT SelectorM
+        : public SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>
+    {
 
-friend SIREMOL_EXPORT QDataStream& ::operator<<<>(QDataStream&, const SelectorM<T>&);
-friend SIREMOL_EXPORT QDataStream& ::operator>><>(QDataStream&, SelectorM<T>&);
+        friend SIREMOL_EXPORT QDataStream & ::operator<< <>(QDataStream &, const SelectorM<T> &);
+        friend SIREMOL_EXPORT QDataStream & ::operator>><>(QDataStream &, SelectorM<T> &);
 
-public:
-    typedef typename QList< Selector<T> >::const_iterator iterator;
-    typedef typename QList< Selector<T> >::const_iterator const_iterator;
+    public:
+        typedef typename QList<Selector<T>>::const_iterator iterator;
+        typedef typename QList<Selector<T>>::const_iterator const_iterator;
 
-    SelectorM();
-    SelectorM(const T &view);
-    SelectorM(const Selector<T> &views);
-    SelectorM(const Molecules &mols);
-    SelectorM(const MoleculeGroup &mols);
-    SelectorM(const MolGroupsBase &mols);
-    SelectorM(const SelectResult &mols);
+        SelectorM();
+        SelectorM(const T &view);
+        SelectorM(const Selector<T> &views);
+        SelectorM(const Molecules &mols);
+        SelectorM(const MoleculeGroup &mols);
+        SelectorM(const MolGroupsBase &mols);
+        SelectorM(const SelectResult &mols);
 
-    SelectorM(const SelectorMol &mols);
-    SelectorM(const SelectorMol &mols, const SireBase::Slice &slice);
-    SelectorM(const SelectorMol &mols, const QList<qint64> &idxs);
-    SelectorM(const SelectorMol &mols, const QString &name,
-              const SireBase::PropertyMap &map = SireBase::PropertyMap());
-    SelectorM(const SelectorMol &mols, const typename T::ID &id);
+        SelectorM(const SelectorMol &mols);
+        SelectorM(const SelectorMol &mols, const SireBase::Slice &slice);
+        SelectorM(const SelectorMol &mols, const QList<qint64> &idxs);
+        SelectorM(const SelectorMol &mols, const QString &name,
+                  const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        SelectorM(const SelectorMol &mols, const typename T::ID &id);
 
-    template<class U>
-    SelectorM(const SelectorM<U> &other);
-    template<class U>
-    SelectorM(const SelectorM<U> &other, const SireBase::Slice &slice);
-    template<class U>
-    SelectorM(const SelectorM<U> &other, const QList<qint64> &idxs);
-    template<class U>
-    SelectorM(const SelectorM<U> &other, const QString &name);
-    template<class U>
-    SelectorM(const SelectorM<U> &other, const typename T::ID &id);
+        template <class U>
+        SelectorM(const SelectorM<U> &other);
+        template <class U>
+        SelectorM(const SelectorM<U> &other, const SireBase::Slice &slice);
+        template <class U>
+        SelectorM(const SelectorM<U> &other, const QList<qint64> &idxs);
+        template <class U>
+        SelectorM(const SelectorM<U> &other, const QString &name);
+        template <class U>
+        SelectorM(const SelectorM<U> &other, const typename T::ID &id);
 
-    SelectorM(const SelectorM<T> &other);
+        SelectorM(const SelectorM<T> &other);
 
-    virtual ~SelectorM();
+        virtual ~SelectorM();
 
-    static const char* typeName();
+        static const char *typeName();
 
-    virtual SelectorM<T>* clone() const
-    {
-        return new SelectorM<T>(*this);
-    }
+        virtual SelectorM<T> *clone() const
+        {
+            return new SelectorM<T>(*this);
+        }
 
-    SelectorM<T>& operator=(const SelectorM<T> &other);
+        SelectorM<T> &operator=(const SelectorM<T> &other);
 
-    bool operator==(const SelectorM<T> &other) const;
-    bool operator!=(const SelectorM<T> &other) const;
+        bool operator==(const SelectorM<T> &other) const;
+        bool operator!=(const SelectorM<T> &other) const;
 
-    T operator[](int i) const;
-    SelectorM<T> operator[](const SireBase::Slice &slice) const;
-    SelectorM<T> operator[](const QList<qint64> &idxs) const;
-    T operator[](const QString &name) const;
-    T operator[](const typename T::ID &id) const;
+        T operator[](int i) const;
+        SelectorM<T> operator[](const SireBase::Slice &slice) const;
+        SelectorM<T> operator[](const QList<qint64> &idxs) const;
+        T operator[](const QString &name) const;
+        T operator[](const typename T::ID &id) const;
 
-    T operator()(int i) const;
-    T operator()(const QString &name) const;
-    T operator()(const typename T::ID &id) const;
+        T operator()(int i) const;
+        T operator()(const QString &name) const;
+        T operator()(const typename T::ID &id) const;
 
-    QList<MolViewPtr> toList() const;
-    Molecules toMolecules() const;
+        QList<MolViewPtr> toList() const;
+        Molecules toMolecules() const;
 
-    int count() const;
-    int size() const;
+        int count() const;
+        int size() const;
 
-    void update(const Molecules &molecules);
+        void update(const Molecules &molecules);
 
-    EvaluatorM evaluate() const;
+        EvaluatorM evaluate() const;
 
-    MoleculeGroup toMoleculeGroup() const;
-    SelectResult toSelectResult() const;
+        MoleculeGroup toMoleculeGroup() const;
+        SelectResult toSelectResult() const;
 
-    bool isSelector() const;
+        bool isSelector() const;
 
-    SelectorM<T> add(const SelectorM<T> &other) const;
-    SelectorM<T> add(const Selector<T> &views) const;
-    SelectorM<T> add(const T &view) const;
+        QList<qint64> find(const T &view) const;
+        QList<qint64> find(const Selector<T> &views) const;
+        QList<qint64> find(const SelectorM<T> &views) const;
 
-    SelectorM<T> subtract(const SelectorM<T> &other) const;
-    SelectorM<T> subtract(const Selector<T> &views) const;
-    SelectorM<T> subtract(const T &view) const;
+        SelectorM<T> add(const SelectorM<T> &other) const;
+        SelectorM<T> add(const Selector<T> &views) const;
+        SelectorM<T> add(const T &view) const;
 
-    SelectorM<T> intersection(const SelectorM<T> &other) const;
-    SelectorM<T> intersection(const Selector<T> &views) const;
-    SelectorM<T> intersection(const T &view) const;
+        SelectorM<T> subtract(const SelectorM<T> &other) const;
+        SelectorM<T> subtract(const Selector<T> &views) const;
+        SelectorM<T> subtract(const T &view) const;
 
-    SelectorM<T> invert() const;
+        SelectorM<T> intersection(const SelectorM<T> &other) const;
+        SelectorM<T> intersection(const Selector<T> &views) const;
+        SelectorM<T> intersection(const T &view) const;
 
-    bool intersects(const SelectorM<T> &other) const;
-    bool intersects(const Selector<T> &view) const;
-    bool intersects(const T &view) const;
+        SelectorM<T> invert() const;
 
-    bool contains(const SelectorM<T> &other) const;
-    bool contains(const Selector<T> &view) const;
-    bool contains(const T &view) const;
+        bool intersects(const SelectorM<T> &other) const;
+        bool intersects(const Selector<T> &view) const;
+        bool intersects(const T &view) const;
 
-    Molecule molecule(int i,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Molecule molecule(const QString &name,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Molecule molecule(const MolID &molid,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        bool contains(const SelectorM<T> &other) const;
+        bool contains(const Selector<T> &view) const;
+        bool contains(const T &view) const;
 
-    SelectorMol molecules() const;
-    SelectorMol molecules(int i,
-                          const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const SireBase::Slice &slice,
-                          const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const QList<qint64> &idxs,
+        Molecule molecule(int i,
                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const QString &name,
+        Molecule molecule(const QString &name,
                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const MolID &molid,
-                          const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-
-    Atom atom(int i,
-              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Atom atom(const QString &name,
-              const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Atom atom(const AtomID &atomid,
-              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-
-    Residue residue(int i,
+        Molecule molecule(const MolID &molid,
+                          const SireBase::PropertyMap &map = SireBase::PropertyMap());
+
+        SelectorMol molecules() const;
+        SelectorMol molecules(int i,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const SireBase::Slice &slice,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const QList<qint64> &idxs,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const QString &name,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const MolID &molid,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        Atom atom(int i,
+                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Atom atom(const QString &name,
+                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Atom atom(const AtomID &atomid,
+                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        Residue residue(int i,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Residue residue(const QString &name,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Residue residue(const ResID &resid,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        Chain chain(int i,
+                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Chain chain(const QString &name,
                     const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Residue residue(const QString &name,
-                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Residue residue(const ResID &resid,
+        Chain chain(const ChainID &chainid,
                     const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
 
-    Chain chain(int i,
-                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Chain chain(const QString &name,
-                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Chain chain(const ChainID &chainid,
-                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Segment segment(int i,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Segment segment(const QString &name,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Segment segment(const SegID &segid,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
 
-    Segment segment(int i,
-                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Segment segment(const QString &name,
-                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Segment segment(const SegID &segid,
-                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        CutGroup cutGroup(int i,
+                          const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        CutGroup cutGroup(const QString &name,
+                          const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        CutGroup cutGroup(const CGID &cgid,
+                          const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
 
-    CutGroup cutGroup(int i,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    CutGroup cutGroup(const QString &name,
-                      const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    CutGroup cutGroup(const CGID &cgid,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-
-    SelectorM<Atom> atoms() const;
-    SelectorM<Atom> atoms(int i,
-                          const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Atom> atoms(const SireBase::Slice &slice,
-                          const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Atom> atoms(const QList<qint64> &idxs,
-                          const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Atom> atoms(const QString &name,
-                          const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Atom> atoms(const AtomID &atomid,
-                          const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectorM<Residue> residues() const;
-    SelectorM<Residue> residues(int i,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Residue> residues(const SireBase::Slice &slice,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Residue> residues(const QList<qint64> &idxs,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Residue> residues(const QString &name,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Residue> residues(const ResID &resid,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectorM<Chain> chains() const;
-    SelectorM<Chain> chains(int i,
-                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Chain> chains(const SireBase::Slice &slice,
-                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Chain> chains(const QList<qint64> &idxs,
-                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Chain> chains(const QString &name,
-                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Chain> chains(const ChainID &chainid,
-                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectorM<Segment> segments() const;
-    SelectorM<Segment> segments(int i,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Segment> segments(const SireBase::Slice &slice,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Segment> segments(const QList<qint64> &idxs,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Segment> segments(const QString &name,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Segment> segments(const SegID &segid,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectorM<CutGroup> cutGroups() const;
-    SelectorM<CutGroup> cutGroups(int i,
-                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<CutGroup> cutGroups(const SireBase::Slice &slice,
-                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<CutGroup> cutGroups(const QList<qint64> &idxs,
-                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<CutGroup> cutGroups(const QString &name,
-                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<CutGroup> cutGroups(const CGID &cgid,
-                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectResult search(const QString &search_string) const;
-    SelectResult search(const QString &search_string,
-                        const SireBase::PropertyMap &map) const;
-
-    QList<typename T::Index> IDs() const;
-    QList<typename T::Index> indexes() const;
-    QList<typename T::Number> numbers() const;
-    QList<typename T::Name> names() const;
-
-    int nAtoms() const;
-    int nResidues() const;
-    int nChains() const;
-    int nSegments() const;
-    int nCutGroups() const;
-    int nMolecules() const;
-
-    bool isEmpty() const;
-
-    int nFrames() const;
-    int nFrames(const SireBase::PropertyMap &map) const;
-
-    void loadFrame(int frame);
-    void saveFrame(int frame);
-    void saveFrame();
-    void deleteFrame(int frame);
-
-    void loadFrame(int frame, const SireBase::PropertyMap &map);
-    void saveFrame(int frame, const SireBase::PropertyMap &map);
-    void saveFrame(const SireBase::PropertyMap &map);
-    void deleteFrame(int frame, const SireBase::PropertyMap &map);
-
-    const_iterator begin() const;
-    const_iterator end() const;
-
-    const_iterator constBegin() const;
-    const_iterator constEnd() const;
-
-    virtual QString toString() const;
-
-protected:
-    void _append(const T &view);
-
-    /** The actual views */
-    QList< Selector<T> > vws;
-};
+        SelectorM<Atom> atoms() const;
+        SelectorM<Atom> atoms(int i,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Atom> atoms(const SireBase::Slice &slice,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Atom> atoms(const QList<qint64> &idxs,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Atom> atoms(const QString &name,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Atom> atoms(const AtomID &atomid,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectorM<Residue> residues() const;
+        SelectorM<Residue> residues(int i,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Residue> residues(const SireBase::Slice &slice,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Residue> residues(const QList<qint64> &idxs,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Residue> residues(const QString &name,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Residue> residues(const ResID &resid,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectorM<Chain> chains() const;
+        SelectorM<Chain> chains(int i,
+                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Chain> chains(const SireBase::Slice &slice,
+                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Chain> chains(const QList<qint64> &idxs,
+                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Chain> chains(const QString &name,
+                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Chain> chains(const ChainID &chainid,
+                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectorM<Segment> segments() const;
+        SelectorM<Segment> segments(int i,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Segment> segments(const SireBase::Slice &slice,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Segment> segments(const QList<qint64> &idxs,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Segment> segments(const QString &name,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Segment> segments(const SegID &segid,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectorM<CutGroup> cutGroups() const;
+        SelectorM<CutGroup> cutGroups(int i,
+                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<CutGroup> cutGroups(const SireBase::Slice &slice,
+                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<CutGroup> cutGroups(const QList<qint64> &idxs,
+                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<CutGroup> cutGroups(const QString &name,
+                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<CutGroup> cutGroups(const CGID &cgid,
+                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectResult search(const QString &search_string) const;
+        SelectResult search(const QString &search_string,
+                            const SireBase::PropertyMap &map) const;
+
+        QList<typename T::Index> IDs() const;
+        QList<typename T::Index> indexes() const;
+        QList<typename T::Number> numbers() const;
+        QList<typename T::Name> names() const;
+
+        int nAtoms() const;
+        int nResidues() const;
+        int nChains() const;
+        int nSegments() const;
+        int nCutGroups() const;
+        int nMolecules() const;
+
+        bool isEmpty() const;
+
+        int nFrames() const;
+        int nFrames(const SireBase::PropertyMap &map) const;
+
+        void loadFrame(int frame);
+        void saveFrame(int frame);
+        void saveFrame();
+        void deleteFrame(int frame);
+
+        void loadFrame(int frame, const SireBase::PropertyMap &map);
+        void saveFrame(int frame, const SireBase::PropertyMap &map);
+        void saveFrame(const SireBase::PropertyMap &map);
+        void deleteFrame(int frame, const SireBase::PropertyMap &map);
+
+        const_iterator begin() const;
+        const_iterator end() const;
+
+        const_iterator constBegin() const;
+        const_iterator constEnd() const;
+
+        virtual QString toString() const;
+
+    protected:
+        void _append(const T &view);
+
+        /** The actual views */
+        QList<Selector<T>> vws;
+    };
 
 #ifndef SIRE_SKIP_INLINE_FUNCTIONS
 
 #ifndef GCCXML_PARSE
-namespace detail
-{
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool _usesParallel(const QList<T> vws, const SireBase::PropertyMap &map)
-{
-    if (vws.count() < 16)
-        return false;
-
-    else if (map["parallel"].hasValue())
+    namespace detail
     {
-        return map["parallel"].value().asA<SireBase::BooleanProperty>().value();
-    }
-
-    return true;
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int _nFrames(const QList<T> &vws, const SireBase::PropertyMap &map)
-{
-    int nframes = std::numeric_limits<int>::max();
 
-    if (_usesParallel(vws, map))
-    {
-        nframes = tbb::parallel_reduce( tbb::blocked_range<int>(0, vws.count()),
-                                        std::numeric_limits<int>::max(),
-                                        [&](tbb::blocked_range<int> r, int my_nframes)
+        template <class T>
+        SIRE_OUTOFLINE_TEMPLATE bool _usesParallel(const QList<T> vws, const SireBase::PropertyMap &map)
         {
-            for (int i=r.begin(); i<r.end(); ++i)
+            if (vws.count() < 16)
+                return false;
+
+            else if (map["parallel"].hasValue())
             {
-                my_nframes = std::min(my_nframes, vws.at(i).nFrames(map));
+                return map["parallel"].value().asA<SireBase::BooleanProperty>().value();
             }
 
-            return my_nframes;
+            return true;
+        }
 
-        }, [](int a, int b){ return std::min(a, b);});
-    }
-    else
-    {
-        for (const auto &view : vws)
+        template <class T>
+        SIRE_OUTOFLINE_TEMPLATE int _nFrames(const QList<T> &vws, const SireBase::PropertyMap &map)
         {
-            nframes = std::min(nframes, view.nFrames(map));
+            int nframes = std::numeric_limits<int>::max();
 
-            if (nframes == 0)
-                break;
-        }
-    }
+            if (_usesParallel(vws, map))
+            {
+                nframes = tbb::parallel_reduce(
+                    tbb::blocked_range<int>(0, vws.count()),
+                    std::numeric_limits<int>::max(),
+                    [&](tbb::blocked_range<int> r, int my_nframes)
+                    {
+                        for (int i = r.begin(); i < r.end(); ++i)
+                        {
+                            my_nframes = std::min(my_nframes, vws.at(i).nFrames(map));
+                        }
+
+                        return my_nframes;
+                    },
+                    [](int a, int b)
+                    { return std::min(a, b); });
+            }
+            else
+            {
+                for (const auto &view : vws)
+                {
+                    nframes = std::min(nframes, view.nFrames(map));
 
-    return nframes;
-}
+                    if (nframes == 0)
+                        break;
+                }
+            }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void _loadFrame(QList<T> &vws, int frame, const SireBase::PropertyMap &map)
-{
-    const int nframes = _nFrames(vws, map);
+            return nframes;
+        }
 
-    if (not (nframes == 0 and frame == 0))
-        frame = SireID::Index(frame).map(nframes);
+        template <class T>
+        SIRE_OUTOFLINE_TEMPLATE void _loadFrame(QList<T> &vws, int frame, const SireBase::PropertyMap &map)
+        {
+            const int nframes = _nFrames(vws, map);
 
-    vws.detach();
-    const int n = vws.count();
+            if (not(nframes == 0 and frame == 0))
+                frame = SireID::Index(frame).map(nframes);
 
-    if (_usesParallel(vws, map))
-    {
-        tbb::parallel_for(tbb::blocked_range<int>(0, n),
-                          [&](tbb::blocked_range<int> r)
-        {
-            for (int i=r.begin(); i<r.end(); ++i)
+            vws.detach();
+            const int n = vws.count();
+
+            if (_usesParallel(vws, map))
             {
-                vws[i].loadFrame(frame, map);
+                tbb::parallel_for(tbb::blocked_range<int>(0, n),
+                                  [&](tbb::blocked_range<int> r)
+                                  {
+                                      for (int i = r.begin(); i < r.end(); ++i)
+                                      {
+                                          vws[i].loadFrame(frame, map);
+                                      }
+                                  });
+            }
+            else
+            {
+                for (int i = 0; i < n; ++i)
+                {
+                    vws[i].loadFrame(frame, map);
+                }
             }
-        });
-    }
-    else
-    {
-        for (int i=0; i<n; ++i)
-        {
-            vws[i].loadFrame(frame, map);
         }
-    }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void _saveFrame(QList<T> &vws, int frame, const SireBase::PropertyMap &map)
-{
-    frame = SireID::Index(frame).map(_nFrames(vws, map));
+        template <class T>
+        SIRE_OUTOFLINE_TEMPLATE void _saveFrame(QList<T> &vws, int frame, const SireBase::PropertyMap &map)
+        {
+            frame = SireID::Index(frame).map(_nFrames(vws, map));
 
-    vws.detach();
-    const int n = vws.count();
+            vws.detach();
+            const int n = vws.count();
 
-    if (_usesParallel(vws, map))
-    {
-        tbb::parallel_for(tbb::blocked_range<int>(0, n),
-                          [&](tbb::blocked_range<int> r)
-        {
-            for (int i=r.begin(); i<r.end(); ++i)
+            if (_usesParallel(vws, map))
             {
-                vws[i].saveFrame(frame, map);
+                tbb::parallel_for(tbb::blocked_range<int>(0, n),
+                                  [&](tbb::blocked_range<int> r)
+                                  {
+                                      for (int i = r.begin(); i < r.end(); ++i)
+                                      {
+                                          vws[i].saveFrame(frame, map);
+                                      }
+                                  });
+            }
+            else
+            {
+                for (int i = 0; i < n; ++i)
+                {
+                    vws[i].saveFrame(frame, map);
+                }
             }
-        });
-    }
-    else
-    {
-        for (int i=0; i<n; ++i)
-        {
-            vws[i].saveFrame(frame, map);
         }
-    }
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void _saveFrame(QList<T> &vws, const SireBase::PropertyMap &map)
-{
-    vws.detach();
-    const int n = vws.count();
 
-    if (_usesParallel(vws, map))
-    {
-        tbb::parallel_for(tbb::blocked_range<int>(0, n),
-                          [&](tbb::blocked_range<int> r)
+        template <class T>
+        SIRE_OUTOFLINE_TEMPLATE void _saveFrame(QList<T> &vws, const SireBase::PropertyMap &map)
         {
-            for (int i=r.begin(); i<r.end(); ++i)
+            vws.detach();
+            const int n = vws.count();
+
+            if (_usesParallel(vws, map))
             {
-                vws[i].saveFrame(map);
+                tbb::parallel_for(tbb::blocked_range<int>(0, n),
+                                  [&](tbb::blocked_range<int> r)
+                                  {
+                                      for (int i = r.begin(); i < r.end(); ++i)
+                                      {
+                                          vws[i].saveFrame(map);
+                                      }
+                                  });
+            }
+            else
+            {
+                for (int i = 0; i < n; ++i)
+                {
+                    vws[i].saveFrame(map);
+                }
             }
-        });
-    }
-    else
-    {
-        for (int i=0; i<n; ++i)
-        {
-            vws[i].saveFrame(map);
         }
-    }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void _deleteFrame(QList<T> &vws, int frame, const SireBase::PropertyMap &map)
-{
-    frame = SireID::Index(frame).map(_nFrames(vws, map));
+        template <class T>
+        SIRE_OUTOFLINE_TEMPLATE void _deleteFrame(QList<T> &vws, int frame, const SireBase::PropertyMap &map)
+        {
+            frame = SireID::Index(frame).map(_nFrames(vws, map));
 
-    vws.detach();
-    const int n = vws.count();
+            vws.detach();
+            const int n = vws.count();
 
-    if (_usesParallel(vws, map))
-    {
-        tbb::parallel_for(tbb::blocked_range<int>(0, n),
-                          [&](tbb::blocked_range<int> r)
-        {
-            for (int i=r.begin(); i<r.end(); ++i)
+            if (_usesParallel(vws, map))
             {
-                vws[i].deleteFrame(frame, map);
+                tbb::parallel_for(tbb::blocked_range<int>(0, n),
+                                  [&](tbb::blocked_range<int> r)
+                                  {
+                                      for (int i = r.begin(); i < r.end(); ++i)
+                                      {
+                                          vws[i].deleteFrame(frame, map);
+                                      }
+                                  });
+            }
+            else
+            {
+                for (int i = 0; i < n; ++i)
+                {
+                    vws[i].deleteFrame(frame, map);
+                }
             }
-        });
-    }
-    else
-    {
-        for (int i=0; i<n; ++i)
-        {
-            vws[i].deleteFrame(frame, map);
         }
-    }
-}
 
-} // end of namespace detail
+    }  // end of namespace detail
 #endif // GCCXML_PARSE
 
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM()
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const T &view)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    this->vws.append(Selector<T>(view));
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const Selector<T> &views)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    if (not views.isEmpty())
-        this->vws.append(views);
-}
-
-template<class T>
-struct _get_view
-{
-    template<class C>
-    static int count(const C &mols)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM()
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        return mols.nAtoms();
     }
 
-    template<class C>
-    static T at(const C &mols, int idx)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const T &view)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        return mols.atom(idx);
+        this->vws.append(Selector<T>(view));
     }
 
-    template<class C>
-    static Selector<Atom> get(const C &view)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const Selector<T> &views)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        if (view.template isA< Selector<Atom> >())
-            return view.template asA< Selector<Atom> >();
-        else
-            return view.atoms();
+        if (not views.isEmpty())
+            this->vws.append(views);
     }
 
-    static SelectorM<T> getName(const SelectorM<T> &view, const QString &name)
+    template <class T>
+    struct _get_view
     {
-        return view.atoms(name);
-    }
+        template <class C>
+        static int count(const C &mols)
+        {
+            return mols.nAtoms();
+        }
 
-    static SelectorM<T> getID(const SelectorM<T> &view,
-                              const typename T::ID &id)
-    {
-        return view.atoms(id);
-    }
+        template <class C>
+        static T at(const C &mols, int idx)
+        {
+            return mols.atom(idx);
+        }
 
-    template<class C, class ID>
-    static Selector<T> get(const C &view, const ID &id)
-    {
-        return view.atoms(id);
-    }
+        template <class C>
+        static Selector<Atom> get(const C &view)
+        {
+            if (view.template isA<Selector<Atom>>())
+                return view.template asA<Selector<Atom>>();
+            else
+                return view.atoms();
+        }
 
-    static void raise_duplicate(const QString &id, int n)
-    {
-        throw SireMol::duplicate_atom(QObject::tr(
-            "Multiple atoms matched %1. Number of matches is %2.")
-                .arg(id).arg(n), CODELOC);
-    }
+        static SelectorM<T> getName(const SelectorM<T> &view, const QString &name)
+        {
+            return view.atoms(name);
+        }
 
-    static void raise_missing(const QString &id)
-    {
-        throw SireMol::missing_atom(QObject::tr(
-            "No atom matches %1.").arg(id), CODELOC);
-    }
-};
+        static SelectorM<T> getID(const SelectorM<T> &view,
+                                  const typename T::ID &id)
+        {
+            return view.atoms(id);
+        }
 
-template<>
-struct _get_view<Residue>
-{
-    template<class C>
-    static int count(const C &mols)
-    {
-        return mols.nResidues();
-    }
+        template <class C, class ID>
+        static Selector<T> get(const C &view, const ID &id)
+        {
+            return view.atoms(id);
+        }
 
-    template<class C>
-    static Residue at(const C &mols, int idx)
-    {
-        return mols.residue(idx);
-    }
+        static void raise_duplicate(const QString &id, int n)
+        {
+            throw SireMol::duplicate_atom(QObject::tr(
+                                              "Multiple atoms matched %1. Number of matches is %2.")
+                                              .arg(id)
+                                              .arg(n),
+                                          CODELOC);
+        }
 
-    static SelectorM<Residue> getName(const SelectorM<Residue> &view,
-                                      const QString &name)
-    {
-        return view.residues(name);
-    }
+        static void raise_missing(const QString &id)
+        {
+            throw SireMol::missing_atom(QObject::tr(
+                                            "No atom matches %1.")
+                                            .arg(id),
+                                        CODELOC);
+        }
+    };
 
-    static SelectorM<Residue> getID(const SelectorM<Residue> &view,
-                                    const Residue::ID &id)
+    template <>
+    struct _get_view<Residue>
     {
-        return view.residues(id);
-    }
+        template <class C>
+        static int count(const C &mols)
+        {
+            return mols.nResidues();
+        }
 
-    template<class C>
-    static Selector<Residue> get(const C &view)
-    {
-        if (view.template isA< Selector<Residue> >())
-            return view.template asA< Selector<Residue> >();
-        else
-            return view.residues();
-    }
+        template <class C>
+        static Residue at(const C &mols, int idx)
+        {
+            return mols.residue(idx);
+        }
 
-    template<class C, class ID>
-    static Selector<Residue> get(const C &view, const ID &id)
-    {
-        return view.residues(id);
-    }
+        static SelectorM<Residue> getName(const SelectorM<Residue> &view,
+                                          const QString &name)
+        {
+            return view.residues(name);
+        }
 
-    static void raise_duplicate(const QString &id, int n)
-    {
-        throw SireMol::duplicate_residue(QObject::tr(
-            "Multiple residues matched %1. Number of matches is %2.")
-                .arg(id).arg(n), CODELOC);
-    }
+        static SelectorM<Residue> getID(const SelectorM<Residue> &view,
+                                        const Residue::ID &id)
+        {
+            return view.residues(id);
+        }
 
-    static void raise_missing(const QString &id)
-    {
-        throw SireMol::missing_residue(QObject::tr(
-            "No residue matches %1.").arg(id), CODELOC);
-    }
-};
+        template <class C>
+        static Selector<Residue> get(const C &view)
+        {
+            if (view.template isA<Selector<Residue>>())
+                return view.template asA<Selector<Residue>>();
+            else
+                return view.residues();
+        }
 
-template<>
-struct _get_view<Chain>
-{
-    template<class C>
-    static int count(const C &mols)
-    {
-        return mols.nChains();
-    }
+        template <class C, class ID>
+        static Selector<Residue> get(const C &view, const ID &id)
+        {
+            return view.residues(id);
+        }
 
-    template<class C>
-    static Chain at(const C &mols, int idx)
-    {
-        return mols.chain(idx);
-    }
+        static void raise_duplicate(const QString &id, int n)
+        {
+            throw SireMol::duplicate_residue(QObject::tr(
+                                                 "Multiple residues matched %1. Number of matches is %2.")
+                                                 .arg(id)
+                                                 .arg(n),
+                                             CODELOC);
+        }
 
-    static SelectorM<Chain> getName(const SelectorM<Chain> &view,
-                                    const QString &name)
-    {
-        return view.chains(name);
-    }
+        static void raise_missing(const QString &id)
+        {
+            throw SireMol::missing_residue(QObject::tr(
+                                               "No residue matches %1.")
+                                               .arg(id),
+                                           CODELOC);
+        }
+    };
 
-    static SelectorM<Chain> getID(const SelectorM<Chain> &view,
-                                  const Chain::ID &id)
+    template <>
+    struct _get_view<Chain>
     {
-        return view.chains(id);
-    }
+        template <class C>
+        static int count(const C &mols)
+        {
+            return mols.nChains();
+        }
 
-    template<class C>
-    static Selector<Chain> get(const C &view)
-    {
-        if (view.template isA< Selector<Chain> >())
-            return view.template asA< Selector<Chain> >();
-        else
-            return view.chains();
-    }
+        template <class C>
+        static Chain at(const C &mols, int idx)
+        {
+            return mols.chain(idx);
+        }
 
-    template<class C, class ID>
-    static Selector<Chain> get(const C &view, const ID &id)
-    {
-        return view.chains(id);
-    }
+        static SelectorM<Chain> getName(const SelectorM<Chain> &view,
+                                        const QString &name)
+        {
+            return view.chains(name);
+        }
 
-    static void raise_duplicate(const QString &id, int n)
-    {
-        throw SireMol::duplicate_chain(QObject::tr(
-            "Multiple chains matched %1. Number of matches is %2.")
-                .arg(id).arg(n), CODELOC);
-    }
+        static SelectorM<Chain> getID(const SelectorM<Chain> &view,
+                                      const Chain::ID &id)
+        {
+            return view.chains(id);
+        }
 
-    static void raise_missing(const QString &id)
-    {
-        throw SireMol::missing_chain(QObject::tr(
-            "No chain matches %1.").arg(id), CODELOC);
-    }
-};
+        template <class C>
+        static Selector<Chain> get(const C &view)
+        {
+            if (view.template isA<Selector<Chain>>())
+                return view.template asA<Selector<Chain>>();
+            else
+                return view.chains();
+        }
 
-template<>
-struct _get_view<CutGroup>
-{
-    template<class C>
-    static int count(const C &mols)
-    {
-        return mols.nCutGroups();
-    }
+        template <class C, class ID>
+        static Selector<Chain> get(const C &view, const ID &id)
+        {
+            return view.chains(id);
+        }
 
-    template<class C>
-    static CutGroup at(const C &mols, int idx)
-    {
-        return mols.cutGroup(idx);
-    }
+        static void raise_duplicate(const QString &id, int n)
+        {
+            throw SireMol::duplicate_chain(QObject::tr(
+                                               "Multiple chains matched %1. Number of matches is %2.")
+                                               .arg(id)
+                                               .arg(n),
+                                           CODELOC);
+        }
 
-    static SelectorM<CutGroup> getName(const SelectorM<CutGroup> &view,
-                                       const QString &name)
-    {
-        return view.cutGroup(name);
-    }
+        static void raise_missing(const QString &id)
+        {
+            throw SireMol::missing_chain(QObject::tr(
+                                             "No chain matches %1.")
+                                             .arg(id),
+                                         CODELOC);
+        }
+    };
 
-    static SelectorM<CutGroup> getID(const SelectorM<Residue> &view,
-                                     const CutGroup::ID &id)
+    template <>
+    struct _get_view<CutGroup>
     {
-        return view.cutGroups(id);
-    }
+        template <class C>
+        static int count(const C &mols)
+        {
+            return mols.nCutGroups();
+        }
 
-    template<class C>
-    static Selector<CutGroup> get(const C &view)
-    {
-        if (view.template isA< Selector<CutGroup> >())
-            return view.template asA< Selector<CutGroup> >();
-        else
-            return view.cutGroups();
-    }
+        template <class C>
+        static CutGroup at(const C &mols, int idx)
+        {
+            return mols.cutGroup(idx);
+        }
 
-    template<class C, class ID>
-    static Selector<CutGroup> get(const C &view, const ID &id)
-    {
-        return view.cutGroups(id);
-    }
+        static SelectorM<CutGroup> getName(const SelectorM<CutGroup> &view,
+                                           const QString &name)
+        {
+            return view.cutGroup(name);
+        }
 
-    static void raise_duplicate(const QString &id, int n)
-    {
-        throw SireMol::duplicate_cutgroup(QObject::tr(
-            "Multiple CutGroups matched %1. Number of matches is %2.")
-                .arg(id).arg(n), CODELOC);
-    }
+        static SelectorM<CutGroup> getID(const SelectorM<Residue> &view,
+                                         const CutGroup::ID &id)
+        {
+            return view.cutGroups(id);
+        }
 
-    static void raise_missing(const QString &id)
-    {
-        throw SireMol::missing_cutgroup(QObject::tr(
-            "No CutGroup matches %1.").arg(id), CODELOC);
-    }
-};
+        template <class C>
+        static Selector<CutGroup> get(const C &view)
+        {
+            if (view.template isA<Selector<CutGroup>>())
+                return view.template asA<Selector<CutGroup>>();
+            else
+                return view.cutGroups();
+        }
 
-template<>
-struct _get_view<Segment>
-{
-    template<class C>
-    static int count(const C &mols)
-    {
-        return mols.nSegments();
-    }
+        template <class C, class ID>
+        static Selector<CutGroup> get(const C &view, const ID &id)
+        {
+            return view.cutGroups(id);
+        }
 
-    template<class C>
-    static Segment at(const C &mols, int idx)
-    {
-        return mols.segment(idx);
-    }
+        static void raise_duplicate(const QString &id, int n)
+        {
+            throw SireMol::duplicate_cutgroup(QObject::tr(
+                                                  "Multiple CutGroups matched %1. Number of matches is %2.")
+                                                  .arg(id)
+                                                  .arg(n),
+                                              CODELOC);
+        }
 
-    static SelectorM<Segment> getName(const SelectorM<Segment> &view,
-                                      const QString &name)
-    {
-        return view.segments(name);
-    }
+        static void raise_missing(const QString &id)
+        {
+            throw SireMol::missing_cutgroup(QObject::tr(
+                                                "No CutGroup matches %1.")
+                                                .arg(id),
+                                            CODELOC);
+        }
+    };
 
-    static SelectorM<Segment> getID(const SelectorM<Segment> &view,
-                                    const Segment::ID &id)
+    template <>
+    struct _get_view<Segment>
     {
-        return view.segments(id);
-    }
+        template <class C>
+        static int count(const C &mols)
+        {
+            return mols.nSegments();
+        }
 
-    template<class C>
-    static Selector<Segment> get(const C &view)
-    {
-        if (view.template isA< Selector<Segment> >())
-            return view.template asA< Selector<Segment> >();
-        else
-            return view.segments();
-    }
+        template <class C>
+        static Segment at(const C &mols, int idx)
+        {
+            return mols.segment(idx);
+        }
 
-    template<class C, class ID>
-    static Selector<Segment> get(const C &view, const ID &id)
-    {
-        return view.segments(id);
-    }
+        static SelectorM<Segment> getName(const SelectorM<Segment> &view,
+                                          const QString &name)
+        {
+            return view.segments(name);
+        }
 
-    static void raise_duplicate(const QString &id, int n)
-    {
-        throw SireMol::duplicate_segment(QObject::tr(
-            "Multiple segments matched %1. Number of matches is %2.")
-                .arg(id).arg(n), CODELOC);
-    }
+        static SelectorM<Segment> getID(const SelectorM<Segment> &view,
+                                        const Segment::ID &id)
+        {
+            return view.segments(id);
+        }
 
-    static void raise_missing(const QString &id)
-    {
-        throw SireMol::missing_segment(QObject::tr(
-            "No segment matches %1.").arg(id), CODELOC);
-    }
-};
+        template <class C>
+        static Selector<Segment> get(const C &view)
+        {
+            if (view.template isA<Selector<Segment>>())
+                return view.template asA<Selector<Segment>>();
+            else
+                return view.segments();
+        }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorMol &mols)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    for (const auto &mol : mols)
-    {
-        this->vws += _get_view<T>::get(mol);
-    }
-}
+        template <class C, class ID>
+        static Selector<Segment> get(const C &view, const ID &id)
+        {
+            return view.segments(id);
+        }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void SelectorM<T>::_append(const T &view)
-{
-    if (this->vws.isEmpty())
-    {
-        this->vws.append(Selector<T>(view));
-    }
-    else if (this->vws.last().data().number() != view.data().number())
+        static void raise_duplicate(const QString &id, int n)
+        {
+            throw SireMol::duplicate_segment(QObject::tr(
+                                                 "Multiple segments matched %1. Number of matches is %2.")
+                                                 .arg(id)
+                                                 .arg(n),
+                                             CODELOC);
+        }
+
+        static void raise_missing(const QString &id)
+        {
+            throw SireMol::missing_segment(QObject::tr(
+                                               "No segment matches %1.")
+                                               .arg(id),
+                                           CODELOC);
+        }
+    };
+
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorMol &mols)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        // new molecule
-        this->vws.append(Selector<T>(view));
+        for (const auto &mol : mols)
+        {
+            this->vws += _get_view<T>::get(mol);
+        }
     }
-    else
+
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE void SelectorM<T>::_append(const T &view)
     {
-        // a new view in the current molecule
-        this->vws.last() = this->vws.last().add(view);
+        if (this->vws.isEmpty())
+        {
+            this->vws.append(Selector<T>(view));
+        }
+        else if (this->vws.last().data().number() != view.data().number())
+        {
+            // new molecule
+            this->vws.append(Selector<T>(view));
+        }
+        else
+        {
+            // a new view in the current molecule
+            this->vws.last() = this->vws.last().add(view);
+        }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const Molecules &molecules)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    if (not molecules.isEmpty())
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const Molecules &molecules)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        auto toList = [](const QSet<MolNum> &molnums)
+        if (not molecules.isEmpty())
         {
-            //return QList<MolNum>(molnums.constBegin(), molnums.constEnd());
-            return molnums.values();
-        };
+            auto toList = [](const QSet<MolNum> &molnums)
+            {
+                // return QList<MolNum>(molnums.constBegin(), molnums.constEnd());
+                return molnums.values();
+            };
 
-        auto molnums = toList(molecules.molNums());
+            auto molnums = toList(molecules.molNums());
 
-        //sort them, as this is also likely the order the molecules
-        //were read in from a file, and so more likely to be the
-        //order the user would expect
-        std::sort(molnums.begin(), molnums.end());
+            // sort them, as this is also likely the order the molecules
+            // were read in from a file, and so more likely to be the
+            // order the user would expect
+            std::sort(molnums.begin(), molnums.end());
 
-        this->vws.reserve(molnums.count());
+            this->vws.reserve(molnums.count());
 
-        for (const auto &molnum : molnums)
-        {
-            this->vws.append(_get_view<T>::get(molecules.at(molnum)));
+            for (const auto &molnum : molnums)
+            {
+                this->vws.append(_get_view<T>::get(molecules.at(molnum)));
+            }
         }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const MoleculeGroup &molecules)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    if (not molecules.isEmpty())
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const MoleculeGroup &molecules)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        const auto molnums = molecules.molNums();
-        this->vws.reserve(molnums.count());
-
-        for (const auto &molnum : molnums)
+        if (not molecules.isEmpty())
         {
-            this->vws.append(_get_view<T>::get(molecules.at(molnum)));
+            const auto molnums = molecules.molNums();
+            this->vws.reserve(molnums.count());
+
+            for (const auto &molnum : molnums)
+            {
+                this->vws.append(_get_view<T>::get(molecules.at(molnum)));
+            }
         }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const MolGroupsBase &molecules)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    if (not molecules.isEmpty())
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const MolGroupsBase &molecules)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        const auto molnums = molecules.molNums();
-        this->vws.reserve(molnums.count());
-
-        for (const auto &molnum : molnums)
+        if (not molecules.isEmpty())
         {
-            this->vws.append(_get_view<T>::get(molecules.at(molnum)));
+            const auto molnums = molecules.molNums();
+            this->vws.reserve(molnums.count());
+
+            for (const auto &molnum : molnums)
+            {
+                this->vws.append(_get_view<T>::get(molecules.at(molnum)));
+            }
         }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectResult &molecules)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    if (not molecules.isEmpty())
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectResult &molecules)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        this->vws.reserve(molecules.count());
-
-        for (const auto &mol : molecules)
+        if (not molecules.isEmpty())
         {
-            this->vws.append(_get_view<T>::get(*mol));
-        }
-    }
-}
+            this->vws.reserve(molecules.count());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorMol &mols, const SireBase::Slice &slice)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    for (auto it = slice.begin(_get_view<T>::count(mols));
-         not it.atEnd(); it.next())
-    {
-        this->_append(_get_view<T>::at(mols, it.value()));
+            for (const auto &mol : molecules)
+            {
+                this->vws.append(_get_view<T>::get(*mol));
+            }
+        }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorMol &mols, const QList<qint64> &idxs)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    for (const auto &idx : idxs)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorMol &mols, const SireBase::Slice &slice)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        this->_append(_get_view<T>::at(mols, idx));
+        for (auto it = slice.begin(_get_view<T>::count(mols));
+             not it.atEnd(); it.next())
+        {
+            this->_append(_get_view<T>::at(mols, it.value()));
+        }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorMol &mols, const QString &name,
-                        const SireBase::PropertyMap &map)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    for (const auto &mol : mols)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorMol &mols, const QList<qint64> &idxs)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        auto flag = SireError::exception::enableFastExceptions();
-
-        try
+        for (const auto &idx : idxs)
         {
-            this->vws.append(_get_view<T>::get(mol, typename T::Name(name)));
+            this->_append(_get_view<T>::at(mols, idx));
         }
-        catch(...)
-        {}
     }
 
-    if (this->vws.isEmpty())
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorMol &mols, const QString &name,
+                            const SireBase::PropertyMap &map)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        // try a search
-        try
+        for (const auto &mol : mols)
         {
-            this->operator=(SelectorM<T>(mols.search(name, map)));
+            auto flag = SireError::exception::enableFastExceptions();
+
+            try
+            {
+                this->vws.append(_get_view<T>::get(mol, typename T::Name(name)));
+            }
+            catch (...)
+            {
+            }
         }
-        catch(...)
+
+        if (this->vws.isEmpty())
         {
-            if (name.length() < 5)
-                //likely a name error
-                _get_view<T>::raise_missing(name);
-            else
-                //likely a syntax error
-                throw;
+            // try a search
+            try
+            {
+                this->operator=(SelectorM<T>(mols.search(name, map)));
+            }
+            catch (...)
+            {
+                if (name.length() < 5)
+                    // likely a name error
+                    _get_view<T>::raise_missing(name);
+                else
+                    // likely a syntax error
+                    throw;
+            }
         }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorMol &mols, const typename T::ID &id)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    for (const auto &mol : mols)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorMol &mols, const typename T::ID &id)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        auto flag = SireError::exception::enableFastExceptions();
-
-        try
+        for (const auto &mol : mols)
         {
-            this->vws.append(_get_view<T>::get(mol, id));
-        }
-        catch(...)
-        {}
-    }
+            auto flag = SireError::exception::enableFastExceptions();
 
-    if (this->vws.isEmpty())
-        _get_view<T>::raise_missing(id.toString());
-}
+            try
+            {
+                this->vws.append(_get_view<T>::get(mol, id));
+            }
+            catch (...)
+            {
+            }
+        }
 
-template<class T>
-template<class U>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorM<U> &other)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    for (const auto &o : other)
-    {
-        this->vws.append(_get_view<T>::get(o));
+        if (this->vws.isEmpty())
+            _get_view<T>::raise_missing(id.toString());
     }
-}
 
-template<class T>
-template<class U>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorM<U> &other, const SireBase::Slice &slice)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    for (auto it = slice.begin(_get_view<T>::count(other));
-         not it.atEnd(); it.next())
+    template <class T>
+    template <class U>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorM<U> &other)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        this->_append(_get_view<T>::at(other, it.value()));
+        for (const auto &o : other)
+        {
+            this->vws.append(_get_view<T>::get(o));
+        }
     }
-}
 
-template<class T>
-template<class U>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorM<U> &other, const QList<qint64> &idxs)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    for (const auto &idx : idxs)
+    template <class T>
+    template <class U>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorM<U> &other, const SireBase::Slice &slice)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        this->_append(_get_view<T>::at(other, idx));
+        for (auto it = slice.begin(_get_view<T>::count(other));
+             not it.atEnd(); it.next())
+        {
+            this->_append(_get_view<T>::at(other, it.value()));
+        }
     }
-}
 
-template<class T>
-template<class U>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorM<U> &other, const QString &name)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    for (const auto &view : other)
+    template <class T>
+    template <class U>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorM<U> &other, const QList<qint64> &idxs)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        auto flag = SireError::exception::enableFastExceptions();
-
-        try
+        for (const auto &idx : idxs)
         {
-            this->vws.append(_get_view<T>::get(view, name));
+            this->_append(_get_view<T>::at(other, idx));
         }
-        catch(...)
-        {}
     }
 
-    if (this->vws.isEmpty())
+    template <class T>
+    template <class U>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorM<U> &other, const QString &name)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        // try a search
-        try
+        for (const auto &view : other)
         {
-            this->operator=(SelectorM<T>(other.search(name)));
+            auto flag = SireError::exception::enableFastExceptions();
+
+            try
+            {
+                this->vws.append(_get_view<T>::get(view, name));
+            }
+            catch (...)
+            {
+            }
         }
-        catch(...)
+
+        if (this->vws.isEmpty())
         {
-            if (name.length() < 5)
-                //likely a name error
-                _get_view<T>::raise_missing(name);
-            else
-                //likely a syntax error
-                throw;
+            // try a search
+            try
+            {
+                this->operator=(SelectorM<T>(other.search(name)));
+            }
+            catch (...)
+            {
+                if (name.length() < 5)
+                    // likely a name error
+                    _get_view<T>::raise_missing(name);
+                else
+                    // likely a syntax error
+                    throw;
+            }
         }
     }
-}
 
-template<class T>
-template<class U>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorM<U> &other, const typename T::ID &id)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>()
-{
-    for (const auto &view : other)
+    template <class T>
+    template <class U>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorM<U> &other, const typename T::ID &id)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>()
     {
-        auto flag = SireError::exception::enableFastExceptions();
-
-        try
+        for (const auto &view : other)
         {
-            this->vws.append(_get_view<T>::get(view, id));
-        }
-        catch(...)
-        {}
-    }
+            auto flag = SireError::exception::enableFastExceptions();
 
-    if (this->vws.isEmpty())
-        _get_view<T>::raise_missing(id.toString());
-}
+            try
+            {
+                this->vws.append(_get_view<T>::get(view, id));
+            }
+            catch (...)
+            {
+            }
+        }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::SelectorM(const SelectorM<T> &other)
-             : SireBase::ConcreteProperty<SelectorM<T>,SireBase::Property>(),
-               vws(other.vws)
-{}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>::~SelectorM()
-{}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-const char* SelectorM<T>::typeName()
-{
-    return QMetaType::typeName( qMetaTypeId< SelectorM<T> >() );
-}
+        if (this->vws.isEmpty())
+            _get_view<T>::raise_missing(id.toString());
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T>& SelectorM<T>::operator=(const SelectorM<T> &other)
-{
-    if (this != &other)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorM<T>::SelectorM(const SelectorM<T> &other)
+        : SireBase::ConcreteProperty<SelectorM<T>, SireBase::Property>(),
+          vws(other.vws)
     {
-        this->vws = other.vws;
-        Property::operator=(other);
     }
 
-    return *this;
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool SelectorM<T>::operator==(const SelectorM<T> &other) const
-{
-    return vws == other.vws;
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool SelectorM<T>::operator!=(const SelectorM<T> &other) const
-{
-    return not this->operator==(other);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>::~SelectorM()
+    {
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-T SelectorM<T>::operator[](int i) const
-{
-    i = SireID::Index(i).map(this->count());
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE const char *SelectorM<T>::typeName()
+    {
+        return QMetaType::typeName(qMetaTypeId<SelectorM<T>>());
+    }
 
-    for (const auto &v : vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T> &
+        SelectorM<T>::operator=(const SelectorM<T> &other)
     {
-        if (i < v.count())
-        {
-            return v(i);
-        }
-        else
+        if (this != &other)
         {
-            i -= v.count();
+            this->vws = other.vws;
+            Property::operator=(other);
         }
+
+        return *this;
     }
 
-    throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool SelectorM<T>::operator==(const SelectorM<T> &other) const
+    {
+        return vws == other.vws;
+    }
 
-    return T();
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool SelectorM<T>::operator!=(const SelectorM<T> &other) const
+    {
+        return not this->operator==(other);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::operator[](const SireBase::Slice &slice) const
-{
-    return SelectorM<T>(*this, slice);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        T
+        SelectorM<T>::operator[](int i) const
+    {
+        i = SireID::Index(i).map(this->count());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::operator[](const QList<qint64> &idxs) const
-{
-    return SelectorM<T>(*this,idxs);
-}
+        for (const auto &v : vws)
+        {
+            if (i < v.count())
+            {
+                return v(i);
+            }
+            else
+            {
+                i -= v.count();
+            }
+        }
 
+        throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-T SelectorM<T>::operator[](const QString &name) const
-{
-    auto all = _get_view<T>::getName(*this, name);
+        return T();
+    }
 
-    if (all.count() > 1)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::operator[](const SireBase::Slice &slice) const
     {
-        _get_view<T>::raise_duplicate(name, all.count());
+        return SelectorM<T>(*this, slice);
     }
 
-    BOOST_ASSERT( not all.isEmpty() );
-
-    return all(0);
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-T SelectorM<T>::operator[](const typename T::ID &id) const
-{
-    auto all = _get_view<T>::getID(*this, id);
-
-    if (all.count() > 1)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::operator[](const QList<qint64> &idxs) const
     {
-        _get_view<T>::raise_duplicate(id.toString(), all.count());
+        return SelectorM<T>(*this, idxs);
     }
 
-    BOOST_ASSERT( not all.isEmpty() );
-
-    return all(0);
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-T SelectorM<T>::operator()(int i) const
-{
-    return this->operator[](i);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        T
+        SelectorM<T>::operator[](const QString &name) const
+    {
+        auto all = _get_view<T>::getName(*this, name);
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-T SelectorM<T>::operator()(const QString &name) const
-{
-    return this->operator[](name);
-}
+        if (all.count() > 1)
+        {
+            _get_view<T>::raise_duplicate(name, all.count());
+        }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-T SelectorM<T>::operator()(const typename T::ID &id) const
-{
-    return this->operator[](id);
-}
+        BOOST_ASSERT(not all.isEmpty());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QList<MolViewPtr> SelectorM<T>::toList() const
-{
-    QList<MolViewPtr> l;
-    l.reserve(vws.count());
+        return all(0);
+    }
 
-    for (const auto &v : vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        T
+        SelectorM<T>::operator[](const typename T::ID &id) const
     {
-        l.append(MolViewPtr(v.clone()));
-    }
+        auto all = _get_view<T>::getID(*this, id);
 
-    return l;
-}
+        if (all.count() > 1)
+        {
+            _get_view<T>::raise_duplicate(id.toString(), all.count());
+        }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Molecules SelectorM<T>::toMolecules() const
-{
-    return Molecules(this->vws);
-}
+        BOOST_ASSERT(not all.isEmpty());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectResult SelectorM<T>::toSelectResult() const
-{
-    return SelectResult(this->vws);
-}
+        return all(0);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool SelectorM<T>::isSelector() const
-{
-    return true;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        T
+        SelectorM<T>::operator()(int i) const
+    {
+        return this->operator[](i);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::add(const SelectorM<T> &other) const
-{
-    SelectorM<T> ret(*this);
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        T
+        SelectorM<T>::operator()(const QString &name) const
+    {
+        return this->operator[](name);
+    }
 
-    for (int i=0; i<other.count(); ++i)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        T
+        SelectorM<T>::operator()(const typename T::ID &id) const
     {
-        ret._append(other(i));
+        return this->operator[](id);
     }
 
-    return ret;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<MolViewPtr>
+        SelectorM<T>::toList() const
+    {
+        QList<MolViewPtr> l;
+        l.reserve(vws.count());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::add(const Selector<T> &other) const
-{
-    SelectorM<T> ret(*this);
+        for (const auto &v : vws)
+        {
+            l.append(MolViewPtr(v.clone()));
+        }
 
-    for (int i=0; i<other.count(); ++i)
-    {
-        ret._append(other(i));
+        return l;
     }
 
-    return ret;
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::add(const T &other) const
-{
-    SelectorM<T> ret(*this);
-    ret._append(other);
-    return ret;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Molecules
+        SelectorM<T>::toMolecules() const
+    {
+        return Molecules(this->vws);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::subtract(const SelectorM<T> &other) const
-{
-    SelectorM<T> ret;
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectResult
+        SelectorM<T>::toSelectResult() const
+    {
+        return SelectResult(this->vws);
+    }
 
-    for (const auto &view : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<qint64>
+        SelectorM<T>::find(const T &view) const
     {
-        auto result = view;
+        QList<qint64> matches;
+
+        qint64 start = 0;
 
-        for (const auto &other_view : other.vws)
+        for (const auto &vw : vws)
         {
-            if (result.data().number() == other_view.data().number())
+            const auto m = vw.find(view);
+
+            if (m.isEmpty())
+            {
+                start += vw.count();
+            }
+            else
             {
-                result = result.subtract(other_view);
+                matches.append(start + m[0]);
+                break;
             }
         }
 
-        if (not result.isEmpty())
-            ret.vws.append(result);
+        return matches;
     }
 
-    return ret;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<qint64>
+        SelectorM<T>::find(const Selector<T> &views) const
+    {
+        QList<qint64> matches;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::subtract(const Selector<T> &other) const
-{
-    SelectorM<T> ret;
+        qint64 start = 0;
 
-    for (const auto &view : this->vws)
-    {
-        if (view.data().number() == other.data().number())
+        for (const auto &vw : vws)
         {
-            auto result = view.subtract(other);
+            const auto m = vw.find(views);
 
-            if (not result.isEmpty())
-                ret.vws.append(result);
+            if (m.isEmpty())
+            {
+                start += vw.count();
+            }
+            else
+            {
+                for (auto match : m)
+                {
+                    matches.append(start + match);
+                }
+
+                if (matches.count() == views.count())
+                    break;
+                else
+                    start += vw.count();
+            }
         }
-        else
-            ret.vws.append(view);
+
+        return matches;
     }
 
-    return ret;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<qint64>
+        SelectorM<T>::find(const SelectorM<T> &views) const
+    {
+        QList<qint64> matches;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::subtract(const T &other) const
-{
-    SelectorM<T> ret;
+        qint64 start = 0;
 
-    for (const auto &view : this->vws)
-    {
-        if (view.data().number() == other.data().number())
+        for (const auto &view : views)
         {
-            auto result = view.subtract(other);
+            const auto m = this->find(view);
 
-            if (not result.isEmpty())
-                ret.vws.append(result);
+            if (not m.isEmpty())
+            {
+                matches += m;
+            }
         }
-        else
-            ret.vws.append(view);
+
+        return matches;
     }
 
-    return ret;
-}
+    template <class T>
+    QList<qint64>
+    Selector<T>::find(const SelectorM<T> &views) const
+    {
+        return SelectorM<T>(*this).find(views);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::intersection(const SelectorM<T> &other) const
-{
-    SelectorM<T> ret;
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool SelectorM<T>::isSelector() const
+    {
+        return true;
+    }
 
-    for (const auto &view : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::add(const SelectorM<T> &other) const
     {
-        for (const auto &other_view : other.vws)
-        {
-            if (view.data().number() == other_view.data().number())
-            {
-                auto intersect = view.intersection(other_view);
+        SelectorM<T> ret(*this);
 
-                if (not intersect.isEmpty())
-                {
-                    ret.vws.append(intersect);
-                }
-            }
+        for (int i = 0; i < other.count(); ++i)
+        {
+            ret._append(other(i));
         }
+
+        return ret;
     }
 
-    return ret;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::add(const Selector<T> &other) const
+    {
+        SelectorM<T> ret(*this);
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::intersection(const Selector<T> &views) const
-{
-    SelectorM<T> ret;
+        for (int i = 0; i < other.count(); ++i)
+        {
+            ret._append(other(i));
+        }
+
+        return ret;
+    }
+
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::add(const T &other) const
+    {
+        SelectorM<T> ret(*this);
+        ret._append(other);
+        return ret;
+    }
 
-    for (const auto &view : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::subtract(const SelectorM<T> &other) const
     {
-        if (view.data().number() == view.data().number())
+        SelectorM<T> ret;
+
+        for (const auto &view : this->vws)
         {
-            auto intersect = view.intersection(views);
+            auto result = view;
 
-            if (not intersect.isEmpty())
+            for (const auto &other_view : other.vws)
             {
-                ret.vws.append(intersect);
+                if (result.data().number() == other_view.data().number())
+                {
+                    result = result.subtract(other_view);
+                }
             }
+
+            if (not result.isEmpty())
+                ret.vws.append(result);
         }
-    }
 
-    return ret;
-}
+        return ret;
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::intersection(const T &view) const
-{
-    if (this->contains(view))
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::subtract(const Selector<T> &other) const
     {
-        return SelectorM<T>(view);
-    }
-    else
-        return SelectorM<T>();
-}
+        SelectorM<T> ret;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<T> SelectorM<T>::invert() const
-{
-    SelectorM<T> ret;
+        for (const auto &view : this->vws)
+        {
+            if (view.data().number() == other.data().number())
+            {
+                auto result = view.subtract(other);
+
+                if (not result.isEmpty())
+                    ret.vws.append(result);
+            }
+            else
+                ret.vws.append(view);
+        }
+
+        return ret;
+    }
 
-    for (const auto &view : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::subtract(const T &other) const
     {
-        auto inverted = view.invert();
+        SelectorM<T> ret;
 
-        if (not inverted.isEmpty())
+        for (const auto &view : this->vws)
         {
-            ret.vws.append(inverted);
+            if (view.data().number() == other.data().number())
+            {
+                auto result = view.subtract(other);
+
+                if (not result.isEmpty())
+                    ret.vws.append(result);
+            }
+            else
+                ret.vws.append(view);
         }
-    }
 
-    return ret;
-}
+        return ret;
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool SelectorM<T>::intersects(const SelectorM<T> &other) const
-{
-    for (int i=0; i<other.count(); ++i)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::intersection(const SelectorM<T> &other) const
     {
-        if (this->contains(other(i)))
+        SelectorM<T> ret;
+
+        for (const auto &view : this->vws)
         {
-            return true;
+            for (const auto &other_view : other.vws)
+            {
+                if (view.data().number() == other_view.data().number())
+                {
+                    auto intersect = view.intersection(other_view);
+
+                    if (not intersect.isEmpty())
+                    {
+                        ret.vws.append(intersect);
+                    }
+                }
+            }
         }
+
+        return ret;
     }
 
-    return false;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::intersection(const Selector<T> &views) const
+    {
+        SelectorM<T> ret;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool SelectorM<T>::intersects(const Selector<T> &other) const
-{
-    for (int i=0; i<other.count(); ++i)
+        for (const auto &view : this->vws)
+        {
+            if (view.data().number() == view.data().number())
+            {
+                auto intersect = view.intersection(views);
+
+                if (not intersect.isEmpty())
+                {
+                    ret.vws.append(intersect);
+                }
+            }
+        }
+
+        return ret;
+    }
+
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::intersection(const T &view) const
     {
-        if (this->contains(other(i)))
+        if (this->contains(view))
         {
-            return true;
+            return SelectorM<T>(view);
         }
+        else
+            return SelectorM<T>();
     }
 
-    return false;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<T>
+        SelectorM<T>::invert() const
+    {
+        SelectorM<T> ret;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool SelectorM<T>::intersects(const T &view) const
-{
-    return this->contains(view);
-}
+        for (const auto &view : this->vws)
+        {
+            auto inverted = view.invert();
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool SelectorM<T>::contains(const SelectorM<T> &other) const
-{
-    for (int i=0; i<other.count(); ++i)
+            if (not inverted.isEmpty())
+            {
+                ret.vws.append(inverted);
+            }
+        }
+
+        return ret;
+    }
+
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool SelectorM<T>::intersects(const SelectorM<T> &other) const
     {
-        if (not this->contains(other(i)))
+        for (int i = 0; i < other.count(); ++i)
         {
-            return false;
+            if (this->contains(other(i)))
+            {
+                return true;
+            }
         }
-    }
 
-    return true;
-}
+        return false;
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool SelectorM<T>::contains(const Selector<T> &other) const
-{
-    for (int i=0; i<other.count(); ++i)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool SelectorM<T>::intersects(const Selector<T> &other) const
     {
-        if (not this->contains(other(i)))
+        for (int i = 0; i < other.count(); ++i)
         {
-            return false;
+            if (this->contains(other(i)))
+            {
+                return true;
+            }
         }
-    }
 
-    return true;
-}
+        return false;
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool SelectorM<T>::contains(const T &other) const
-{
-    for (const auto &view : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool SelectorM<T>::intersects(const T &view) const
     {
-        if (view == other)
-            return true;
+        return this->contains(view);
     }
 
-    return false;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool SelectorM<T>::contains(const SelectorM<T> &other) const
+    {
+        for (int i = 0; i < other.count(); ++i)
+        {
+            if (not this->contains(other(i)))
+            {
+                return false;
+            }
+        }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void SelectorM<T>::update(const Molecules &molecules)
-{
-    // better to create a map from MolNum to index here
-    QMultiHash<MolNum, int> molnum_to_idx;
-    molnum_to_idx.reserve(this->vws.count());
+        return true;
+    }
+
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool SelectorM<T>::contains(const Selector<T> &other) const
+    {
+        for (int i = 0; i < other.count(); ++i)
+        {
+            if (not this->contains(other(i)))
+            {
+                return false;
+            }
+        }
 
-    int i = 0;
+        return true;
+    }
 
-    for (const auto &view : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool SelectorM<T>::contains(const T &other) const
     {
-        molnum_to_idx.insert(view.data().number(), i);
-        i += 1;
+        for (const auto &view : this->vws)
+        {
+            if (view == other)
+                return true;
+        }
+
+        return false;
     }
 
-    for (const auto &mol : molecules)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE void SelectorM<T>::update(const Molecules &molecules)
     {
-        const auto molnum = mol.data().number();
+        // better to create a map from MolNum to index here
+        QMultiHash<MolNum, int> molnum_to_idx;
+        molnum_to_idx.reserve(this->vws.count());
 
-        auto it = molnum_to_idx.constFind(molnum);
+        int i = 0;
 
-        while (it != molnum_to_idx.constEnd() && it.key() == molnum)
+        for (const auto &view : this->vws)
         {
-            this->vws[it.value()].update(mol.data());
+            molnum_to_idx.insert(view.data().number(), i);
+            i += 1;
         }
-    }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectResult SelectorM<T>::search(const QString &search_term) const
-{
-    Select search(search_term);
-    return search(this->toSelectResult());
-}
+        for (const auto &mol : molecules)
+        {
+            const auto molnum = mol.data().number();
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectResult SelectorM<T>::search(const QString &search_term,
-                                  const SireBase::PropertyMap &map) const
-{
-    Select search(search_term);
-    return search(this->toSelectResult(), map);
-}
+            auto it = molnum_to_idx.constFind(molnum);
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int SelectorM<T>::count() const
-{
-    int n = 0;
+            while (it != molnum_to_idx.constEnd() && it.key() == molnum)
+            {
+                this->vws[it.value()].update(mol.data());
+            }
+        }
+    }
 
-    for (const auto &v : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectResult
+        SelectorM<T>::search(const QString &search_term) const
     {
-        n += v.count();
+        Select search(search_term);
+        return search(this->toSelectResult());
     }
 
-    return n;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectResult
+        SelectorM<T>::search(const QString &search_term,
+                             const SireBase::PropertyMap &map) const
+    {
+        Select search(search_term);
+        return search(this->toSelectResult(), map);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int SelectorM<T>::size() const
-{
-    return this->count();
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int SelectorM<T>::count() const
+    {
+        int n = 0;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-MoleculeGroup SelectorM<T>::toMoleculeGroup() const
-{
-    MoleculeGroup grp;
+        for (const auto &v : this->vws)
+        {
+            n += v.count();
+        }
+
+        return n;
+    }
 
-    for (const auto &view : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int SelectorM<T>::size() const
     {
-        grp.add(view);
+        return this->count();
     }
 
-    return grp;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        MoleculeGroup
+        SelectorM<T>::toMoleculeGroup() const
+    {
+        MoleculeGroup grp;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Molecule SelectorM<T>::molecule(int i,
-                                const SireBase::PropertyMap&) const
-{
-    i = SireID::Index(i).map(this->vws.count());
+        for (const auto &view : this->vws)
+        {
+            grp.add(view);
+        }
 
-    return this->vws.at(i).molecule();
-}
+        return grp;
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Molecule SelectorM<T>::molecule(const QString &name,
-                                const SireBase::PropertyMap &map) const
-{
-    auto mols = this->molecules(name, map);
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Molecule
+        SelectorM<T>::molecule(int i,
+                               const SireBase::PropertyMap &) const
+    {
+        i = SireID::Index(i).map(this->vws.count());
 
-    if (mols.count() > 1)
-        throw SireMol::duplicate_molecule(QObject::tr(
-            "More than one molecule matches '%1'. Number of matches is %2.")
-                .arg(name).arg(mols.count()), CODELOC);
+        return this->vws.at(i).molecule();
+    }
 
-    BOOST_ASSERT(not mols.isEmpty());
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Molecule
+        SelectorM<T>::molecule(const QString &name,
+                               const SireBase::PropertyMap &map) const
+    {
+        auto mols = this->molecules(name, map);
 
-    return mols[0];
-}
+        if (mols.count() > 1)
+            throw SireMol::duplicate_molecule(QObject::tr(
+                                                  "More than one molecule matches '%1'. Number of matches is %2.")
+                                                  .arg(name)
+                                                  .arg(mols.count()),
+                                              CODELOC);
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Molecule SelectorM<T>::molecule(const MolID &molid,
-                                const SireBase::PropertyMap &map)
-{
-    auto mols = this->molecules(molid, map);
+        BOOST_ASSERT(not mols.isEmpty());
 
-    if (mols.count() > 1)
-        throw SireMol::duplicate_molecule(QObject::tr(
-            "More than one molecule matches '%1'. Number of matches is %2.")
-                .arg(molid.toString()).arg(mols.count()), CODELOC);
+        return mols[0];
+    }
 
-    BOOST_ASSERT(not mols.isEmpty());
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Molecule
+        SelectorM<T>::molecule(const MolID &molid,
+                               const SireBase::PropertyMap &map)
+    {
+        auto mols = this->molecules(molid, map);
 
-    return mols[0];
-}
+        if (mols.count() > 1)
+            throw SireMol::duplicate_molecule(QObject::tr(
+                                                  "More than one molecule matches '%1'. Number of matches is %2.")
+                                                  .arg(molid.toString())
+                                                  .arg(mols.count()),
+                                              CODELOC);
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol SelectorM<T>::molecules() const
-{
-    return SelectorMol(*this);
-}
+        BOOST_ASSERT(not mols.isEmpty());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol SelectorM<T>::molecules(int i,
-                                    const SireBase::PropertyMap &map) const
-{
-    return SelectorMol(this->molecule(i, map));
-}
+        return mols[0];
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol SelectorM<T>::molecules(const SireBase::Slice &slice,
-                                    const SireBase::PropertyMap&) const
-{
-    return SelectorMol(*this, slice);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorMol
+        SelectorM<T>::molecules() const
+    {
+        return SelectorMol(*this);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol SelectorM<T>::molecules(const QList<qint64> &idxs,
-                                    const SireBase::PropertyMap&) const
-{
-    return SelectorMol(*this, idxs);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorMol
+        SelectorM<T>::molecules(int i,
+                                const SireBase::PropertyMap &map) const
+    {
+        return SelectorMol(this->molecule(i, map));
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol SelectorM<T>::molecules(const QString &name,
-                                    const SireBase::PropertyMap &map) const
-{
-    return SelectorMol(*this, name, map);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorMol
+        SelectorM<T>::molecules(const SireBase::Slice &slice,
+                                const SireBase::PropertyMap &) const
+    {
+        return SelectorMol(*this, slice);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol SelectorM<T>::molecules(const MolID &molid,
-                                    const SireBase::PropertyMap&) const
-{
-    return SelectorMol(*this, molid);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorMol
+        SelectorM<T>::molecules(const QList<qint64> &idxs,
+                                const SireBase::PropertyMap &) const
+    {
+        return SelectorMol(*this, idxs);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Atom SelectorM<T>::atom(int i, const SireBase::PropertyMap&) const
-{
-    i = SireID::Index(i).map(this->nAtoms());
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorMol
+        SelectorM<T>::molecules(const QString &name,
+                                const SireBase::PropertyMap &map) const
+    {
+        return SelectorMol(*this, name, map);
+    }
 
-    for (const auto &v : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorMol
+        SelectorM<T>::molecules(const MolID &molid,
+                                const SireBase::PropertyMap &) const
     {
-        if (i < v.nAtoms())
-        {
-            return v.atom(i);
-        }
-        else
-        {
-            i -= v.nAtoms();
-        }
+        return SelectorMol(*this, molid);
     }
 
-    throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Atom
+        SelectorM<T>::atom(int i, const SireBase::PropertyMap &) const
+    {
+        i = SireID::Index(i).map(this->nAtoms());
 
-    return Atom();
-}
+        for (const auto &v : this->vws)
+        {
+            if (i < v.nAtoms())
+            {
+                return v.atom(i);
+            }
+            else
+            {
+                i -= v.nAtoms();
+            }
+        }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Atom SelectorM<T>::atom(const QString &name,
-                        const SireBase::PropertyMap &map) const
-{
-    auto all = this->atoms(name, map);
+        throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
+
+        return Atom();
+    }
 
-    if (all.count() > 1)
-        _get_view<Atom>::raise_duplicate(name, all.count());
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Atom
+        SelectorM<T>::atom(const QString &name,
+                           const SireBase::PropertyMap &map) const
+    {
+        auto all = this->atoms(name, map);
 
-    BOOST_ASSERT( not all.isEmpty() );
+        if (all.count() > 1)
+            _get_view<Atom>::raise_duplicate(name, all.count());
 
-    return all[0];
-}
+        BOOST_ASSERT(not all.isEmpty());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Atom SelectorM<T>::atom(const AtomID &atomid,
-                        const SireBase::PropertyMap &map) const
-{
-    auto all = this->atoms(atomid, map);
+        return all[0];
+    }
 
-    if (all.count() > 1)
-        _get_view<Atom>::raise_duplicate(atomid.toString(), all.count());
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Atom
+        SelectorM<T>::atom(const AtomID &atomid,
+                           const SireBase::PropertyMap &map) const
+    {
+        auto all = this->atoms(atomid, map);
 
-    BOOST_ASSERT( not all.isEmpty() );
+        if (all.count() > 1)
+            _get_view<Atom>::raise_duplicate(atomid.toString(), all.count());
 
-    return all[0];
-}
+        BOOST_ASSERT(not all.isEmpty());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Residue SelectorM<T>::residue(int i, const SireBase::PropertyMap&) const
-{
-    i = SireID::Index(i).map(this->nResidues());
+        return all[0];
+    }
 
-    for (const auto &v : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Residue
+        SelectorM<T>::residue(int i, const SireBase::PropertyMap &) const
     {
-        if (i < v.nResidues())
-        {
-            return v.residue(i);
-        }
-        else
+        i = SireID::Index(i).map(this->nResidues());
+
+        for (const auto &v : this->vws)
         {
-            i -= v.nResidues();
+            if (i < v.nResidues())
+            {
+                return v.residue(i);
+            }
+            else
+            {
+                i -= v.nResidues();
+            }
         }
-    }
 
-    throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
+        throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
 
-    return Residue();
-}
+        return Residue();
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Residue SelectorM<T>::residue(const QString &name,
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Residue
+        SelectorM<T>::residue(const QString &name,
                               const SireBase::PropertyMap &map) const
-{
-    auto all = this->residues(name, map);
+    {
+        auto all = this->residues(name, map);
 
-    if (all.count() > 1)
-        _get_view<Residue>::raise_duplicate(name, all.count());
+        if (all.count() > 1)
+            _get_view<Residue>::raise_duplicate(name, all.count());
 
-    BOOST_ASSERT( not all.isEmpty() );
+        BOOST_ASSERT(not all.isEmpty());
 
-    return all[0];
-}
+        return all[0];
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Residue SelectorM<T>::residue(const ResID &resid,
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Residue
+        SelectorM<T>::residue(const ResID &resid,
                               const SireBase::PropertyMap &map) const
-{
-    auto all = this->residues(resid, map);
-
-    if (all.count() > 1)
-        _get_view<Residue>::raise_duplicate(resid.toString(), all.count());
+    {
+        auto all = this->residues(resid, map);
 
-    BOOST_ASSERT( not all.isEmpty() );
+        if (all.count() > 1)
+            _get_view<Residue>::raise_duplicate(resid.toString(), all.count());
 
-    return all[0];
-}
+        BOOST_ASSERT(not all.isEmpty());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Chain SelectorM<T>::chain(int i, const SireBase::PropertyMap&) const
-{
-    i = SireID::Index(i).map(this->nChains());
+        return all[0];
+    }
 
-    for (const auto &v : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Chain
+        SelectorM<T>::chain(int i, const SireBase::PropertyMap &) const
     {
-        if (i < v.nChains())
-        {
-            return v.chain(i);
-        }
-        else
+        i = SireID::Index(i).map(this->nChains());
+
+        for (const auto &v : this->vws)
         {
-            i -= v.nChains();
+            if (i < v.nChains())
+            {
+                return v.chain(i);
+            }
+            else
+            {
+                i -= v.nChains();
+            }
         }
-    }
 
-    throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
+        throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
 
-    return Chain();
-}
+        return Chain();
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Chain SelectorM<T>::chain(const QString &name,
-                          const SireBase::PropertyMap &map) const
-{
-    auto all = this->chains(name, map);
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Chain
+        SelectorM<T>::chain(const QString &name,
+                            const SireBase::PropertyMap &map) const
+    {
+        auto all = this->chains(name, map);
 
-    if (all.count() > 1)
-        _get_view<Chain>::raise_duplicate(name, all.count());
+        if (all.count() > 1)
+            _get_view<Chain>::raise_duplicate(name, all.count());
 
-    BOOST_ASSERT( not all.isEmpty() );
+        BOOST_ASSERT(not all.isEmpty());
 
-    return all[0];
-}
+        return all[0];
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Chain SelectorM<T>::chain(const ChainID &chainid,
-                          const SireBase::PropertyMap &map) const
-{
-    auto all = this->chains(chainid);
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Chain
+        SelectorM<T>::chain(const ChainID &chainid,
+                            const SireBase::PropertyMap &map) const
+    {
+        auto all = this->chains(chainid);
 
-    if (all.count() > 1)
-        _get_view<Chain>::raise_duplicate(chainid.toString(), all.count());
+        if (all.count() > 1)
+            _get_view<Chain>::raise_duplicate(chainid.toString(), all.count());
 
-    BOOST_ASSERT( not all.isEmpty() );
+        BOOST_ASSERT(not all.isEmpty());
 
-    return all[0];
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Segment SelectorM<T>::segment(int i, const SireBase::PropertyMap&) const
-{
-    i = SireID::Index(i).map(this->nSegments());
+        return all[0];
+    }
 
-    for (const auto &v : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Segment
+        SelectorM<T>::segment(int i, const SireBase::PropertyMap &) const
     {
-        if (i < v.nSegments())
-        {
-            return v.segment(i);
-        }
-        else
+        i = SireID::Index(i).map(this->nSegments());
+
+        for (const auto &v : this->vws)
         {
-            i -= v.nSegments();
+            if (i < v.nSegments())
+            {
+                return v.segment(i);
+            }
+            else
+            {
+                i -= v.nSegments();
+            }
         }
-    }
 
-    throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
+        throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
 
-    return Segment();
-}
+        return Segment();
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Segment SelectorM<T>::segment(const QString &name,
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Segment
+        SelectorM<T>::segment(const QString &name,
                               const SireBase::PropertyMap &map) const
-{
-    auto all = this->segments(name, map);
+    {
+        auto all = this->segments(name, map);
 
-    if (all.count() > 1)
-        _get_view<Segment>::raise_duplicate(name, all.count());
+        if (all.count() > 1)
+            _get_view<Segment>::raise_duplicate(name, all.count());
 
-    BOOST_ASSERT( not all.isEmpty() );
+        BOOST_ASSERT(not all.isEmpty());
 
-    return all[0];
-}
+        return all[0];
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-Segment SelectorM<T>::segment(const SegID &segid,
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        Segment
+        SelectorM<T>::segment(const SegID &segid,
                               const SireBase::PropertyMap &map) const
-{
-    auto all = this->segments(segid, map);
+    {
+        auto all = this->segments(segid, map);
 
-    if (all.count() > 1)
-        _get_view<Segment>::raise_duplicate(segid.toString(), all.count());
+        if (all.count() > 1)
+            _get_view<Segment>::raise_duplicate(segid.toString(), all.count());
 
-    BOOST_ASSERT( not all.isEmpty() );
+        BOOST_ASSERT(not all.isEmpty());
 
-    return all[0];
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-CutGroup SelectorM<T>::cutGroup(int i, const SireBase::PropertyMap&) const
-{
-    i = SireID::Index(i).map(this->nCutGroups());
+        return all[0];
+    }
 
-    for (const auto &v : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        CutGroup
+        SelectorM<T>::cutGroup(int i, const SireBase::PropertyMap &) const
     {
-        if (i < v.nCutGroups())
-        {
-            return v.cutGroup(i);
-        }
-        else
+        i = SireID::Index(i).map(this->nCutGroups());
+
+        for (const auto &v : this->vws)
         {
-            i -= v.nCutGroups();
+            if (i < v.nCutGroups())
+            {
+                return v.cutGroup(i);
+            }
+            else
+            {
+                i -= v.nCutGroups();
+            }
         }
-    }
-
-    throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
 
-    return CutGroup();
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-CutGroup SelectorM<T>::cutGroup(const QString &name,
-                                const SireBase::PropertyMap &map) const
-{
-    auto all = this->cutGroups(name, map);
+        throw SireError::program_bug(QObject::tr("Should not get here!"), CODELOC);
 
-    if (all.count() > 1)
-        _get_view<CutGroup>::raise_duplicate(name, all.count());
+        return CutGroup();
+    }
 
-    BOOST_ASSERT( not all.isEmpty() );
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        CutGroup
+        SelectorM<T>::cutGroup(const QString &name,
+                               const SireBase::PropertyMap &map) const
+    {
+        auto all = this->cutGroups(name, map);
 
-    return all[0];
-}
+        if (all.count() > 1)
+            _get_view<CutGroup>::raise_duplicate(name, all.count());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-CutGroup SelectorM<T>::cutGroup(const CGID &cgid,
-                                const SireBase::PropertyMap &map) const
-{
-    auto all = this->cutGroups(cgid, map);
+        BOOST_ASSERT(not all.isEmpty());
 
-    if (all.count() > 1)
-        _get_view<CutGroup>::raise_duplicate(cgid.toString(), all.count());
+        return all[0];
+    }
 
-    BOOST_ASSERT( not all.isEmpty() );
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        CutGroup
+        SelectorM<T>::cutGroup(const CGID &cgid,
+                               const SireBase::PropertyMap &map) const
+    {
+        auto all = this->cutGroups(cgid, map);
 
-    return all[0];
-}
+        if (all.count() > 1)
+            _get_view<CutGroup>::raise_duplicate(cgid.toString(), all.count());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Atom> SelectorM<T>::atoms() const
-{
-    return SelectorM<Atom>(*this);
-}
+        BOOST_ASSERT(not all.isEmpty());
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Atom> SelectorM<T>::atoms(int i, const SireBase::PropertyMap &map) const
-{
-    return SelectorM<Atom>(this->atom(i,map));
-}
+        return all[0];
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Atom> SelectorM<T>::atoms(const SireBase::Slice &slice,
-                                    const SireBase::PropertyMap&) const
-{
-    return SelectorM<Atom>(*this, slice);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Atom>
+        SelectorM<T>::atoms() const
+    {
+        return SelectorM<Atom>(*this);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Atom> SelectorM<T>::atoms(const QList<qint64> &idxs,
-                                    const SireBase::PropertyMap&) const
-{
-    return SelectorM<Atom>(*this, idxs);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Atom>
+        SelectorM<T>::atoms(int i, const SireBase::PropertyMap &map) const
+    {
+        return SelectorM<Atom>(this->atom(i, map));
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Atom> SelectorM<T>::atoms(const QString &name,
-                                    const SireBase::PropertyMap &map) const
-{
-    return SelectorM<Atom>(*this, name, map);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Atom>
+        SelectorM<T>::atoms(const SireBase::Slice &slice,
+                            const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Atom>(*this, slice);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Atom> SelectorM<T>::atoms(const AtomID &atomid,
-                                    const SireBase::PropertyMap&) const
-{
-    return SelectorM<Atom>(*this, atomid);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Atom>
+        SelectorM<T>::atoms(const QList<qint64> &idxs,
+                            const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Atom>(*this, idxs);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Residue> SelectorM<T>::residues() const
-{
-    return SelectorM<Residue>(*this);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Atom>
+        SelectorM<T>::atoms(const QString &name,
+                            const SireBase::PropertyMap &map) const
+    {
+        return SelectorM<Atom>(*this, name, map);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Residue> SelectorM<T>::residues(int i,
-                                          const SireBase::PropertyMap &map) const
-{
-    return SelectorM<Residue>(this->residue(i, map));
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Atom>
+        SelectorM<T>::atoms(const AtomID &atomid,
+                            const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Atom>(*this, atomid);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Residue> SelectorM<T>::residues(const SireBase::Slice &slice,
-                                          const SireBase::PropertyMap&) const
-{
-    return SelectorM<Residue>(*this, slice);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Residue>
+        SelectorM<T>::residues() const
+    {
+        return SelectorM<Residue>(*this);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Residue> SelectorM<T>::residues(const QList<qint64> &idxs,
-                                          const SireBase::PropertyMap&) const
-{
-    return SelectorM<Residue>(*this, idxs);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Residue>
+        SelectorM<T>::residues(int i,
+                               const SireBase::PropertyMap &map) const
+    {
+        return SelectorM<Residue>(this->residue(i, map));
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Residue> SelectorM<T>::residues(const QString &name,
-                                          const SireBase::PropertyMap &map) const
-{
-    return SelectorM<Residue>(*this, name, map);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Residue>
+        SelectorM<T>::residues(const SireBase::Slice &slice,
+                               const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Residue>(*this, slice);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Residue> SelectorM<T>::residues(const ResID &resid,
-                                          const SireBase::PropertyMap&) const
-{
-    return SelectorM<Residue>(*this, resid);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Residue>
+        SelectorM<T>::residues(const QList<qint64> &idxs,
+                               const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Residue>(*this, idxs);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Chain> SelectorM<T>::chains() const
-{
-    return SelectorM<Chain>(*this);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Residue>
+        SelectorM<T>::residues(const QString &name,
+                               const SireBase::PropertyMap &map) const
+    {
+        return SelectorM<Residue>(*this, name, map);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Chain> SelectorM<T>::chains(int i,
-                                      const SireBase::PropertyMap &map) const
-{
-    return SelectorM<Chain>(this->chain(i, map));
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Residue>
+        SelectorM<T>::residues(const ResID &resid,
+                               const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Residue>(*this, resid);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Chain> SelectorM<T>::chains(const SireBase::Slice &slice,
-                                      const SireBase::PropertyMap&) const
-{
-    return SelectorM<Chain>(*this, slice);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Chain>
+        SelectorM<T>::chains() const
+    {
+        return SelectorM<Chain>(*this);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Chain> SelectorM<T>::chains(const QList<qint64> &idxs,
-                                      const SireBase::PropertyMap&) const
-{
-    return SelectorM<Chain>(*this, idxs);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Chain>
+        SelectorM<T>::chains(int i,
+                             const SireBase::PropertyMap &map) const
+    {
+        return SelectorM<Chain>(this->chain(i, map));
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Chain> SelectorM<T>::chains(const QString &name,
-                                      const SireBase::PropertyMap &map) const
-{
-    return SelectorM<Chain>(*this, name, map);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Chain>
+        SelectorM<T>::chains(const SireBase::Slice &slice,
+                             const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Chain>(*this, slice);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Chain> SelectorM<T>::chains(const ChainID &chainid,
-                                      const SireBase::PropertyMap&) const
-{
-    return SelectorM<Chain>(*this, chainid);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Chain>
+        SelectorM<T>::chains(const QList<qint64> &idxs,
+                             const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Chain>(*this, idxs);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Segment> SelectorM<T>::segments() const
-{
-    return SelectorM<Segment>(*this);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Chain>
+        SelectorM<T>::chains(const QString &name,
+                             const SireBase::PropertyMap &map) const
+    {
+        return SelectorM<Chain>(*this, name, map);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Segment> SelectorM<T>::segments(int i,
-                                          const SireBase::PropertyMap &map) const
-{
-    return SelectorM<Segment>(this->segment(i, map));
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Chain>
+        SelectorM<T>::chains(const ChainID &chainid,
+                             const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Chain>(*this, chainid);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Segment> SelectorM<T>::segments(const SireBase::Slice &slice,
-                                          const SireBase::PropertyMap&) const
-{
-    return SelectorM<Segment>(*this, slice);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Segment>
+        SelectorM<T>::segments() const
+    {
+        return SelectorM<Segment>(*this);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Segment> SelectorM<T>::segments(const QList<qint64> &idxs,
-                                          const SireBase::PropertyMap&) const
-{
-    return SelectorM<Segment>(*this, idxs);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Segment>
+        SelectorM<T>::segments(int i,
+                               const SireBase::PropertyMap &map) const
+    {
+        return SelectorM<Segment>(this->segment(i, map));
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Segment> SelectorM<T>::segments(const QString &name,
-                                          const SireBase::PropertyMap &map) const
-{
-    return SelectorM<Segment>(*this, name, map);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Segment>
+        SelectorM<T>::segments(const SireBase::Slice &slice,
+                               const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Segment>(*this, slice);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<Segment> SelectorM<T>::segments(const SegID &segid,
-                                          const SireBase::PropertyMap&) const
-{
-    return SelectorM<Segment>(*this, segid);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Segment>
+        SelectorM<T>::segments(const QList<qint64> &idxs,
+                               const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Segment>(*this, idxs);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<CutGroup> SelectorM<T>::cutGroups() const
-{
-    return SelectorM<CutGroup>(*this);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Segment>
+        SelectorM<T>::segments(const QString &name,
+                               const SireBase::PropertyMap &map) const
+    {
+        return SelectorM<Segment>(*this, name, map);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<CutGroup> SelectorM<T>::cutGroups(int i,
-                                            const SireBase::PropertyMap &map) const
-{
-    return SelectorM<CutGroup>(this->cutGroup(i, map));
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<Segment>
+        SelectorM<T>::segments(const SegID &segid,
+                               const SireBase::PropertyMap &) const
+    {
+        return SelectorM<Segment>(*this, segid);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<CutGroup> SelectorM<T>::cutGroups(const SireBase::Slice &slice,
-                                            const SireBase::PropertyMap&) const
-{
-    return SelectorM<CutGroup>(*this, slice);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<CutGroup>
+        SelectorM<T>::cutGroups() const
+    {
+        return SelectorM<CutGroup>(*this);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<CutGroup> SelectorM<T>::cutGroups(const QList<qint64> &idxs,
-                                            const SireBase::PropertyMap&) const
-{
-    return SelectorM<CutGroup>(*this, idxs);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<CutGroup>
+        SelectorM<T>::cutGroups(int i,
+                                const SireBase::PropertyMap &map) const
+    {
+        return SelectorM<CutGroup>(this->cutGroup(i, map));
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<CutGroup> SelectorM<T>::cutGroups(const QString &name,
-                                            const SireBase::PropertyMap &map) const
-{
-    return SelectorM<CutGroup>(*this, name, map);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<CutGroup>
+        SelectorM<T>::cutGroups(const SireBase::Slice &slice,
+                                const SireBase::PropertyMap &) const
+    {
+        return SelectorM<CutGroup>(*this, slice);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorM<CutGroup> SelectorM<T>::cutGroups(const CGID &cgid,
-                                            const SireBase::PropertyMap&) const
-{
-    return SelectorM<CutGroup>(*this, cgid);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<CutGroup>
+        SelectorM<T>::cutGroups(const QList<qint64> &idxs,
+                                const SireBase::PropertyMap &) const
+    {
+        return SelectorM<CutGroup>(*this, idxs);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QList<typename T::Index> SelectorM<T>::IDs() const
-{
-    QList<typename T::Index> ids;
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<CutGroup>
+        SelectorM<T>::cutGroups(const QString &name,
+                                const SireBase::PropertyMap &map) const
+    {
+        return SelectorM<CutGroup>(*this, name, map);
+    }
 
-    for (const auto &v : this->vws)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        SelectorM<CutGroup>
+        SelectorM<T>::cutGroups(const CGID &cgid,
+                                const SireBase::PropertyMap &) const
     {
-        ids += v.IDs();
+        return SelectorM<CutGroup>(*this, cgid);
     }
 
-    return ids;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<typename T::Index>
+        SelectorM<T>::IDs() const
+    {
+        QList<typename T::Index> ids;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QList<typename T::Index> SelectorM<T>::indexes() const
-{
-    QList<typename T::Index> idxs;
+        for (const auto &v : this->vws)
+        {
+            ids += v.IDs();
+        }
 
-    for (const auto &v : this->vws)
-    {
-        idxs += v.indexes();
+        return ids;
     }
 
-    return idxs;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<typename T::Index>
+        SelectorM<T>::indexes() const
+    {
+        QList<typename T::Index> idxs;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QList<typename T::Number> SelectorM<T>::numbers() const
-{
-    QList<typename T::Number> nums;
+        for (const auto &v : this->vws)
+        {
+            idxs += v.indexes();
+        }
 
-    for (const auto &v : this->vws)
-    {
-        nums += v.numbers();
+        return idxs;
     }
 
-    return nums;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<typename T::Number>
+        SelectorM<T>::numbers() const
+    {
+        QList<typename T::Number> nums;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QList<typename T::Name> SelectorM<T>::names() const
-{
-    QList<typename T::Name> nmes;
+        for (const auto &v : this->vws)
+        {
+            nums += v.numbers();
+        }
 
-    for (const auto &v : this->vws)
-    {
-        nmes += v.names();
+        return nums;
     }
 
-    return nmes;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QList<typename T::Name>
+        SelectorM<T>::names() const
+    {
+        QList<typename T::Name> nmes;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int SelectorM<T>::nAtoms() const
-{
-    int n = 0;
+        for (const auto &v : this->vws)
+        {
+            nmes += v.names();
+        }
 
-    for (const auto &v : this->vws)
-    {
-        n += v.nAtoms();
+        return nmes;
     }
 
-    return n;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int SelectorM<T>::nAtoms() const
+    {
+        int n = 0;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int SelectorM<T>::nResidues() const
-{
-    int n = 0;
+        for (const auto &v : this->vws)
+        {
+            n += v.nAtoms();
+        }
 
-    for (const auto &v : this->vws)
-    {
-        n += v.nResidues();
+        return n;
     }
 
-    return n;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int SelectorM<T>::nResidues() const
+    {
+        int n = 0;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int SelectorM<T>::nChains() const
-{
-    int n = 0;
+        for (const auto &v : this->vws)
+        {
+            n += v.nResidues();
+        }
 
-    for (const auto &v : this->vws)
-    {
-        n += v.nChains();
+        return n;
     }
 
-    return n;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int SelectorM<T>::nChains() const
+    {
+        int n = 0;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int SelectorM<T>::nSegments() const
-{
-    int n = 0;
+        for (const auto &v : this->vws)
+        {
+            n += v.nChains();
+        }
 
-    for (const auto &v : this->vws)
-    {
-        n += v.nSegments();
+        return n;
     }
 
-    return n;
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int SelectorM<T>::nSegments() const
+    {
+        int n = 0;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int SelectorM<T>::nCutGroups() const
-{
-    int n = 0;
+        for (const auto &v : this->vws)
+        {
+            n += v.nSegments();
+        }
 
-    for (const auto &v : this->vws)
-    {
-        n += v.nCutGroups();
+        return n;
     }
 
-    return n;
-}
-
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int SelectorM<T>::nMolecules() const
-{
-    return this->vws.count();
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int SelectorM<T>::nCutGroups() const
+    {
+        int n = 0;
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int SelectorM<T>::nFrames() const
-{
-    return this->nFrames(PropertyMap());
-}
+        for (const auto &v : this->vws)
+        {
+            n += v.nCutGroups();
+        }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-int SelectorM<T>::nFrames(const SireBase::PropertyMap &map) const
-{
-    return SireMol::detail::_nFrames(this->vws, map);
-}
+        return n;
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void SelectorM<T>::loadFrame(int frame)
-{
-    this->loadFrame(frame, PropertyMap());
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int SelectorM<T>::nMolecules() const
+    {
+        return this->vws.count();
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void SelectorM<T>::saveFrame(int frame)
-{
-    this->saveFrame(frame, PropertyMap());
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int SelectorM<T>::nFrames() const
+    {
+        return this->nFrames(PropertyMap());
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void SelectorM<T>::saveFrame()
-{
-    this->saveFrame(PropertyMap());
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE int SelectorM<T>::nFrames(const SireBase::PropertyMap &map) const
+    {
+        return SireMol::detail::_nFrames(this->vws, map);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void SelectorM<T>::deleteFrame(int frame)
-{
-    this->deleteFrame(frame, PropertyMap());
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE void SelectorM<T>::loadFrame(int frame)
+    {
+        this->loadFrame(frame, PropertyMap());
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void SelectorM<T>::loadFrame(int frame, const SireBase::PropertyMap &map)
-{
-    SireMol::detail::_loadFrame(this->vws, frame, map);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE void SelectorM<T>::saveFrame(int frame)
+    {
+        this->saveFrame(frame, PropertyMap());
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void SelectorM<T>::saveFrame(int frame, const SireBase::PropertyMap &map)
-{
-    SireMol::detail::_saveFrame(this->vws, frame, map);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE void SelectorM<T>::saveFrame()
+    {
+        this->saveFrame(PropertyMap());
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void SelectorM<T>::saveFrame(const SireBase::PropertyMap &map)
-{
-    SireMol::detail::_saveFrame(this->vws, map);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE void SelectorM<T>::deleteFrame(int frame)
+    {
+        this->deleteFrame(frame, PropertyMap());
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-void SelectorM<T>::deleteFrame(int frame, const SireBase::PropertyMap &map)
-{
-    SireMol::detail::_deleteFrame(this->vws, frame, map);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE void SelectorM<T>::loadFrame(int frame, const SireBase::PropertyMap &map)
+    {
+        SireMol::detail::_loadFrame(this->vws, frame, map);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-bool SelectorM<T>::isEmpty() const
-{
-    return this->vws.isEmpty();
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE void SelectorM<T>::saveFrame(int frame, const SireBase::PropertyMap &map)
+    {
+        SireMol::detail::_saveFrame(this->vws, frame, map);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-typename SelectorM<T>::const_iterator SelectorM<T>::begin() const
-{
-    return this->vws.constBegin();
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE void SelectorM<T>::saveFrame(const SireBase::PropertyMap &map)
+    {
+        SireMol::detail::_saveFrame(this->vws, map);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-typename SelectorM<T>::const_iterator SelectorM<T>::end() const
-{
-    return this->vws.constEnd();
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE void SelectorM<T>::deleteFrame(int frame, const SireBase::PropertyMap &map)
+    {
+        SireMol::detail::_deleteFrame(this->vws, frame, map);
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-typename SelectorM<T>::const_iterator SelectorM<T>::constBegin() const
-{
-    return this->vws.constBegin();
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE bool SelectorM<T>::isEmpty() const
+    {
+        return this->vws.isEmpty();
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-typename SelectorM<T>::const_iterator SelectorM<T>::constEnd() const
-{
-    return this->vws.constEnd();
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        typename SelectorM<T>::const_iterator
+        SelectorM<T>::begin() const
+    {
+        return this->vws.constBegin();
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-QString SelectorM<T>::toString() const
-{
-    if (this->isEmpty())
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        typename SelectorM<T>::const_iterator
+        SelectorM<T>::end() const
     {
-        return QObject::tr("%1::empty").arg(this->what());
+        return this->vws.constEnd();
     }
-    else
+
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        typename SelectorM<T>::const_iterator
+        SelectorM<T>::constBegin() const
     {
-        QStringList parts;
+        return this->vws.constBegin();
+    }
 
-        const auto n = this->count();
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        typename SelectorM<T>::const_iterator
+        SelectorM<T>::constEnd() const
+    {
+        return this->vws.constEnd();
+    }
 
-        if (n <= 10)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        QString
+        SelectorM<T>::toString() const
+    {
+        if (this->isEmpty())
         {
-            for (int i=0; i<n; ++i)
-            {
-                const auto view = this->operator[](i);
-
-                parts.append(QString("%1: %2 %3")
-                    .arg(i).arg(view.data().number().toString())
-                    .arg(view.toString()));
-            }
+            return QObject::tr("%1::empty").arg(this->what());
         }
         else
         {
-            for (int i=0; i<5; ++i)
+            QStringList parts;
+
+            const auto n = this->count();
+
+            if (n <= 10)
             {
-                const auto view = this->operator[](i);
+                for (int i = 0; i < n; ++i)
+                {
+                    const auto view = this->operator[](i);
 
-                parts.append(QString("%1: %2 %3")
-                    .arg(i).arg(view.data().number().toString())
-                    .arg(view.toString()));
+                    parts.append(QString("%1: %2 %3")
+                                     .arg(i)
+                                     .arg(view.data().number().toString())
+                                     .arg(view.toString()));
+                }
             }
+            else
+            {
+                for (int i = 0; i < 5; ++i)
+                {
+                    const auto view = this->operator[](i);
 
-            parts.append("...");
+                    parts.append(QString("%1: %2 %3")
+                                     .arg(i)
+                                     .arg(view.data().number().toString())
+                                     .arg(view.toString()));
+                }
 
-            for (int i=n-5; i<n; ++i)
-            {
-                const auto view = this->operator[](i);
+                parts.append("...");
+
+                for (int i = n - 5; i < n; ++i)
+                {
+                    const auto view = this->operator[](i);
 
-                parts.append(QString("%1: %2 %3")
-                    .arg(i).arg(view.data().number().toString())
-                    .arg(view.toString()));
+                    parts.append(QString("%1: %2 %3")
+                                     .arg(i)
+                                     .arg(view.data().number().toString())
+                                     .arg(view.toString()));
+                }
             }
-        }
 
-        return QObject::tr("%1( size=%2\n%3\n)")
-                    .arg(this->what()).arg(n)
-                    .arg(parts.join("\n"));
+            return QObject::tr("%1( size=%2\n%3\n)")
+                .arg(this->what())
+                .arg(n)
+                .arg(parts.join("\n"));
+        }
     }
-}
 
 #endif // SIRE_SKIP_INLINE_FUNCTIONS
 
@@ -2497,25 +2677,26 @@ QString SelectorM<T>::toString() const
 namespace SireMol
 {
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-EvaluatorM::EvaluatorM(const SelectorM<T> &views)
-           : SireBase::ConcreteProperty<EvaluatorM,SireBase::Property>()
-{
-    this->vws.reserve(views.count());
-
-    for (const auto &view : views)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    EvaluatorM::EvaluatorM(const SelectorM<T> &views)
+        : SireBase::ConcreteProperty<EvaluatorM, SireBase::Property>()
     {
-        this->vws.append(PartialMolecule(view));
+        this->vws.reserve(views.count());
+
+        for (const auto &view : views)
+        {
+            this->vws.append(PartialMolecule(view));
+        }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-EvaluatorM SelectorM<T>::evaluate() const
-{
-    return EvaluatorM(*this);
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+        EvaluatorM
+        SelectorM<T>::evaluate() const
+    {
+        return EvaluatorM(*this);
+    }
 
 } // end of namespace SireMol
 
diff --git a/corelib/src/libs/SireMol/selectormol.cpp b/corelib/src/libs/SireMol/selectormol.cpp
index 95b4cc5ca..5aea86ee8 100644
--- a/corelib/src/libs/SireMol/selectormol.cpp
+++ b/corelib/src/libs/SireMol/selectormol.cpp
@@ -56,11 +56,11 @@ using namespace SireMol;
 using namespace SireID;
 
 RegisterMetaType<SelectorMol> r_smol;
-RegisterMetaType< SelectorM<Atom> > r_satm;
-RegisterMetaType< SelectorM<Residue> > r_sres;
-RegisterMetaType< SelectorM<Chain> > r_schn;
-RegisterMetaType< SelectorM<Segment> > r_sseg;
-RegisterMetaType< SelectorM<CutGroup> > r_scg;
+RegisterMetaType<SelectorM<Atom>> r_satm;
+RegisterMetaType<SelectorM<Residue>> r_sres;
+RegisterMetaType<SelectorM<Chain>> r_schn;
+RegisterMetaType<SelectorM<Segment>> r_sseg;
+RegisterMetaType<SelectorM<CutGroup>> r_scg;
 
 /** Serialise to a binary datastream */
 SIREMOL_EXPORT QDataStream &operator<<(QDataStream &ds, const SelectorMol &mols)
@@ -69,7 +69,7 @@ SIREMOL_EXPORT QDataStream &operator<<(QDataStream &ds, const SelectorMol &mols)
 
     SharedDataStream sds(ds);
 
-    sds << mols.mols << static_cast<const Property&>(mols);
+    sds << mols.mols << static_cast<const Property &>(mols);
 
     return ds;
 }
@@ -82,7 +82,7 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorMol &mols)
     if (v == 1)
     {
         SharedDataStream sds(ds);
-        sds >> mols.mols >> static_cast<Property&>(mols);
+        sds >> mols.mols >> static_cast<Property &>(mols);
     }
     else
         throw version_error(v, "1", r_smol, CODELOC);
@@ -91,20 +91,20 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorMol &mols)
 }
 
 /** Serialise to a binary datastream */
-template<>
+template <>
 SIREMOL_EXPORT QDataStream &operator<<(QDataStream &ds, const SelectorM<Atom> &mols)
 {
     writeHeader(ds, r_satm, 1);
 
     SharedDataStream sds(ds);
 
-    sds << mols.vws << static_cast<const Property&>(mols);
+    sds << mols.vws << static_cast<const Property &>(mols);
 
     return ds;
 }
 
 /** Extract from a binary datastream */
-template<>
+template <>
 SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Atom> &mols)
 {
     VersionID v = readHeader(ds, r_satm);
@@ -112,7 +112,7 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Atom> &mols)
     if (v == 1)
     {
         SharedDataStream sds(ds);
-        sds >> mols.vws >> static_cast<Property&>(mols);
+        sds >> mols.vws >> static_cast<Property &>(mols);
     }
     else
         throw version_error(v, "1", r_satm, CODELOC);
@@ -120,20 +120,20 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Atom> &mols)
     return ds;
 }
 /** Serialise to a binary datastream */
-template<>
+template <>
 SIREMOL_EXPORT QDataStream &operator<<(QDataStream &ds, const SelectorM<Residue> &mols)
 {
     writeHeader(ds, r_sres, 1);
 
     SharedDataStream sds(ds);
 
-    sds << mols.vws << static_cast<const Property&>(mols);
+    sds << mols.vws << static_cast<const Property &>(mols);
 
     return ds;
 }
 
 /** Extract from a binary datastream */
-template<>
+template <>
 SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Residue> &mols)
 {
     VersionID v = readHeader(ds, r_sres);
@@ -141,7 +141,7 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Residue> &mols
     if (v == 1)
     {
         SharedDataStream sds(ds);
-        sds >> mols.vws >> static_cast<Property&>(mols);
+        sds >> mols.vws >> static_cast<Property &>(mols);
     }
     else
         throw version_error(v, "1", r_sres, CODELOC);
@@ -149,20 +149,20 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Residue> &mols
     return ds;
 }
 /** Serialise to a binary datastream */
-template<>
+template <>
 SIREMOL_EXPORT QDataStream &operator<<(QDataStream &ds, const SelectorM<Chain> &mols)
 {
     writeHeader(ds, r_schn, 1);
 
     SharedDataStream sds(ds);
 
-    sds << mols.vws << static_cast<const Property&>(mols);
+    sds << mols.vws << static_cast<const Property &>(mols);
 
     return ds;
 }
 
 /** Extract from a binary datastream */
-template<>
+template <>
 SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Chain> &mols)
 {
     VersionID v = readHeader(ds, r_schn);
@@ -170,7 +170,7 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Chain> &mols)
     if (v == 1)
     {
         SharedDataStream sds(ds);
-        sds >> mols.vws >> static_cast<Property&>(mols);
+        sds >> mols.vws >> static_cast<Property &>(mols);
     }
     else
         throw version_error(v, "1", r_schn, CODELOC);
@@ -178,20 +178,20 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Chain> &mols)
     return ds;
 }
 /** Serialise to a binary datastream */
-template<>
+template <>
 SIREMOL_EXPORT QDataStream &operator<<(QDataStream &ds, const SelectorM<Segment> &mols)
 {
     writeHeader(ds, r_sseg, 1);
 
     SharedDataStream sds(ds);
 
-    sds << mols.vws << static_cast<const Property&>(mols);
+    sds << mols.vws << static_cast<const Property &>(mols);
 
     return ds;
 }
 
 /** Extract from a binary datastream */
-template<>
+template <>
 SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Segment> &mols)
 {
     VersionID v = readHeader(ds, r_sseg);
@@ -199,7 +199,7 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Segment> &mols
     if (v == 1)
     {
         SharedDataStream sds(ds);
-        sds >> mols.vws >> static_cast<Property&>(mols);
+        sds >> mols.vws >> static_cast<Property &>(mols);
     }
     else
         throw version_error(v, "1", r_sseg, CODELOC);
@@ -207,20 +207,20 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<Segment> &mols
     return ds;
 }
 /** Serialise to a binary datastream */
-template<>
+template <>
 SIREMOL_EXPORT QDataStream &operator<<(QDataStream &ds, const SelectorM<CutGroup> &mols)
 {
     writeHeader(ds, r_scg, 1);
 
     SharedDataStream sds(ds);
 
-    sds << mols.vws << static_cast<const Property&>(mols);
+    sds << mols.vws << static_cast<const Property &>(mols);
 
     return ds;
 }
 
 /** Extract from a binary datastream */
-template<>
+template <>
 SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<CutGroup> &mols)
 {
     VersionID v = readHeader(ds, r_scg);
@@ -228,7 +228,7 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<CutGroup> &mol
     if (v == 1)
     {
         SharedDataStream sds(ds);
-        sds >> mols.vws >> static_cast<Property&>(mols);
+        sds >> mols.vws >> static_cast<Property &>(mols);
     }
     else
         throw version_error(v, "1", r_scg, CODELOC);
@@ -236,17 +236,18 @@ SIREMOL_EXPORT QDataStream &operator>>(QDataStream &ds, SelectorM<CutGroup> &mol
     return ds;
 }
 
-SelectorMol::SelectorMol() : ConcreteProperty<SelectorMol,Property>()
-{}
+SelectorMol::SelectorMol() : ConcreteProperty<SelectorMol, Property>()
+{
+}
 
 SelectorMol::SelectorMol(const MoleculeView &mol)
-            : ConcreteProperty<SelectorMol,Property>()
+    : ConcreteProperty<SelectorMol, Property>()
 {
     this->mols.append(mol.molecule());
 }
 
 SelectorMol::SelectorMol(const Molecules &molecules)
-            : ConcreteProperty<SelectorMol,Property>()
+    : ConcreteProperty<SelectorMol, Property>()
 {
     if (not molecules.isEmpty())
     {
@@ -257,9 +258,9 @@ SelectorMol::SelectorMol(const Molecules &molecules)
 
         auto molnums = toList(molecules.molNums());
 
-        //sort them, as this is also likely the order the molecules
-        //were read in from a file, and so more likely to be the
-        //order the user would expect
+        // sort them, as this is also likely the order the molecules
+        // were read in from a file, and so more likely to be the
+        // order the user would expect
         std::sort(molnums.begin(), molnums.end());
 
         this->mols.reserve(molnums.count());
@@ -272,7 +273,7 @@ SelectorMol::SelectorMol(const Molecules &molecules)
 }
 
 SelectorMol::SelectorMol(const MoleculeGroup &molecules)
-            : ConcreteProperty<SelectorMol,Property>()
+    : ConcreteProperty<SelectorMol, Property>()
 {
     if (not molecules.isEmpty())
     {
@@ -287,7 +288,7 @@ SelectorMol::SelectorMol(const MoleculeGroup &molecules)
 }
 
 SelectorMol::SelectorMol(const MolGroupsBase &molecules)
-            : ConcreteProperty<SelectorMol,Property>()
+    : ConcreteProperty<SelectorMol, Property>()
 {
     if (not molecules.isEmpty())
     {
@@ -302,7 +303,7 @@ SelectorMol::SelectorMol(const MolGroupsBase &molecules)
 }
 
 SelectorMol::SelectorMol(const SelectResult &molecules)
-            : ConcreteProperty<SelectorMol,Property>()
+    : ConcreteProperty<SelectorMol, Property>()
 {
     if (not molecules.isEmpty())
     {
@@ -316,19 +317,21 @@ SelectorMol::SelectorMol(const SelectResult &molecules)
 }
 
 SelectorMol::SelectorMol(const SelectorMol &other)
-            : ConcreteProperty<SelectorMol,Property>(),
-              mols(other.mols)
-{}
+    : ConcreteProperty<SelectorMol, Property>(),
+      mols(other.mols)
+{
+}
 
 SelectorMol::~SelectorMol()
-{}
+{
+}
 
-const char* SelectorMol::typeName()
+const char *SelectorMol::typeName()
 {
     return QMetaType::typeName(qMetaTypeId<SelectorMol>());
 }
 
-SelectorMol& SelectorMol::operator=(const SelectorMol &other)
+SelectorMol &SelectorMol::operator=(const SelectorMol &other)
 {
     if (this != &other)
     {
@@ -417,6 +420,49 @@ bool SelectorMol::isSelector() const
     return true;
 }
 
+/** Return the index of 'view' in this list of molecules.
+ *  Returns an empty list if the view is not in this collection
+ */
+QList<qint64> SelectorMol::find(const Molecule &view) const
+{
+    QList<qint64> matches;
+
+    for (int i = 0; i < mols.count(); ++i)
+    {
+        if (mols.at(i).isSameMolecule(view))
+        {
+            matches.append(i);
+            break;
+        }
+    }
+
+    return matches;
+}
+
+/** Return the index of 'views' in this list of molecules.
+ *  Returns an empty list if none of the views are in this collection
+ */
+QList<qint64> SelectorMol::find(const SelectorMol &views) const
+{
+    QList<qint64> matches;
+
+    for (int i = 0; i < views.count(); ++i)
+    {
+        const auto &view = views[i];
+
+        for (int j = 0; j < mols.count(); ++j)
+        {
+            if (mols.at(j).isSameMolecule(view))
+            {
+                matches.append(j);
+                break;
+            }
+        }
+    }
+
+    return matches;
+}
+
 void SelectorMol::update(const Molecules &molecules)
 {
     // better to create a map from MolNum to index here
@@ -483,7 +529,7 @@ bool SelectorMol::contains(const MolNum &molnum) const
     return false;
 }
 
-Molecule SelectorMol::molecule(int i, const PropertyMap&) const
+Molecule SelectorMol::molecule(int i, const PropertyMap &) const
 {
     return this->mols.at(Index(i).map(this->mols.count()));
 }
@@ -494,8 +540,10 @@ Molecule SelectorMol::molecule(const QString &name, const PropertyMap &map) cons
 
     if (m.count() > 1)
         throw SireMol::duplicate_molecule(QObject::tr(
-            "More than one molecule matches %1. Number of matches is %2.")
-                .arg(name).arg(m.count()), CODELOC);
+                                              "More than one molecule matches %1. Number of matches is %2.")
+                                              .arg(name)
+                                              .arg(m.count()),
+                                          CODELOC);
 
     BOOST_ASSERT(m.count() != 0);
 
@@ -508,8 +556,10 @@ Molecule SelectorMol::molecule(const MolIdx &molid, const PropertyMap &map) cons
 
     if (m.count() > 1)
         throw SireMol::duplicate_molecule(QObject::tr(
-            "More than one molecule matches %1. Number of matches is %2.")
-                .arg(molid.toString()).arg(m.count()), CODELOC);
+                                              "More than one molecule matches %1. Number of matches is %2.")
+                                              .arg(molid.toString())
+                                              .arg(m.count()),
+                                          CODELOC);
 
     BOOST_ASSERT(m.count() != 0);
 
@@ -522,8 +572,10 @@ Molecule SelectorMol::molecule(const MolName &molid, const PropertyMap &map) con
 
     if (m.count() > 1)
         throw SireMol::duplicate_molecule(QObject::tr(
-            "More than one molecule matches %1. Number of matches is %2.")
-                .arg(molid.toString()).arg(m.count()), CODELOC);
+                                              "More than one molecule matches %1. Number of matches is %2.")
+                                              .arg(molid.toString())
+                                              .arg(m.count()),
+                                          CODELOC);
 
     BOOST_ASSERT(m.count() != 0);
 
@@ -536,8 +588,10 @@ Molecule SelectorMol::molecule(const MolNum &molid, const PropertyMap &map) cons
 
     if (m.count() > 1)
         throw SireMol::duplicate_molecule(QObject::tr(
-            "More than one molecule matches %1. Number of matches is %2.")
-                .arg(molid.toString()).arg(m.count()), CODELOC);
+                                              "More than one molecule matches %1. Number of matches is %2.")
+                                              .arg(molid.toString())
+                                              .arg(m.count()),
+                                          CODELOC);
 
     BOOST_ASSERT(m.count() != 0);
 
@@ -550,8 +604,10 @@ Molecule SelectorMol::molecule(const MolID &molid, const PropertyMap &map) const
 
     if (m.count() > 1)
         throw SireMol::duplicate_molecule(QObject::tr(
-            "More than one molecule matches %1. Number of matches is %2.")
-                .arg(molid.toString()).arg(m.count()), CODELOC);
+                                              "More than one molecule matches %1. Number of matches is %2.")
+                                              .arg(molid.toString())
+                                              .arg(m.count()),
+                                          CODELOC);
 
     BOOST_ASSERT(m.count() != 0);
 
@@ -569,7 +625,7 @@ SelectorMol SelectorMol::molecules(int i, const PropertyMap &map) const
 }
 
 SelectorMol SelectorMol::molecules(const SireBase::Slice &slice,
-                                   const PropertyMap&) const
+                                   const PropertyMap &) const
 {
     SelectorMol m;
 
@@ -582,7 +638,7 @@ SelectorMol SelectorMol::molecules(const SireBase::Slice &slice,
 }
 
 SelectorMol SelectorMol::molecules(const QList<qint64> &idxs,
-                                   const PropertyMap&) const
+                                   const PropertyMap &) const
 {
     SelectorMol m;
 
@@ -601,7 +657,7 @@ SelectorMol SelectorMol::molecules(const QString &name,
     {
         return this->molecules(MolName(name));
     }
-    catch(const SireError::exception &e)
+    catch (const SireError::exception &e)
     {
         try
         {
@@ -609,17 +665,19 @@ SelectorMol SelectorMol::molecules(const QString &name,
 
             if (ret.count() == 0)
                 throw SireMol::missing_molecule(QObject::tr(
-                    "No molecule matches '%1'").arg(name), CODELOC);
+                                                    "No molecule matches '%1'")
+                                                    .arg(name),
+                                                CODELOC);
 
             return ret;
         }
-        catch(...)
+        catch (...)
         {
             if (name.length() < 5)
-                //likely a name error
+                // likely a name error
                 e.throwSelf();
             else
-                //likely a syntax error
+                // likely a syntax error
                 throw;
         }
     }
@@ -634,7 +692,7 @@ SelectorMol SelectorMol::molecules(const MolIdx &molid,
 }
 
 SelectorMol SelectorMol::molecules(const MolName &molname,
-                                   const PropertyMap&) const
+                                   const PropertyMap &) const
 {
     SelectorMol m;
 
@@ -648,14 +706,15 @@ SelectorMol SelectorMol::molecules(const MolName &molname,
 
     if (m.isEmpty())
         throw SireMol::missing_molecule(QObject::tr(
-            "There is no molecule called %1 in this container.")
-                .arg(molname), CODELOC);
+                                            "There is no molecule called %1 in this container.")
+                                            .arg(molname),
+                                        CODELOC);
 
     return m;
 }
 
 SelectorMol SelectorMol::molecules(const MolNum &molnum,
-                                   const PropertyMap&) const
+                                   const PropertyMap &) const
 {
     SelectorMol m;
 
@@ -671,8 +730,9 @@ SelectorMol SelectorMol::molecules(const MolNum &molnum,
 
     if (m.isEmpty())
         throw SireMol::missing_molecule(QObject::tr(
-            "There is no molecule with number %1 in this container.")
-                .arg(molnum), CODELOC);
+                                            "There is no molecule with number %1 in this container.")
+                                            .arg(molnum),
+                                        CODELOC);
 
     return m;
 }
@@ -690,13 +750,13 @@ MoleculeGroup SelectorMol::toMoleculeGroup() const
 }
 
 SelectorMol SelectorMol::molecules(const MolID &molid,
-                                   const PropertyMap&) const
+                                   const PropertyMap &) const
 {
     auto molnums = molid.map(this->toMoleculeGroup());
 
     QHash<MolNum, Molecule> m;
 
-    //QSet<MolNum> molnums_set(molnums.constBegin(), molnums.constEnd());
+    // QSet<MolNum> molnums_set(molnums.constBegin(), molnums.constEnd());
     QSet<MolNum> molnums_set = _list_to_set(molnums);
 
     for (const auto &mol : this->mols)
@@ -723,7 +783,7 @@ SelectorMol SelectorMol::molecules(const MolID &molid,
     return ret;
 }
 
-Atom SelectorMol::atom(int i, const PropertyMap&) const
+Atom SelectorMol::atom(int i, const PropertyMap &) const
 {
     i = Index(i).map(this->nAtoms());
 
@@ -747,8 +807,10 @@ Atom SelectorMol::atom(const QString &name,
 
     if (atms.count() > 1)
         throw SireMol::duplicate_atom(QObject::tr(
-            "More than one atom matches the name '%1'. Number of matches is %2.")
-                .arg(name).arg(atms.count()), CODELOC);
+                                          "More than one atom matches the name '%1'. Number of matches is %2.")
+                                          .arg(name)
+                                          .arg(atms.count()),
+                                      CODELOC);
 
     BOOST_ASSERT(not atms.isEmpty());
 
@@ -761,15 +823,17 @@ Atom SelectorMol::atom(const AtomID &atomid, const PropertyMap &map) const
 
     if (atms.count() > 1)
         throw SireMol::duplicate_atom(QObject::tr(
-            "More than one atom matches '%1'. Number of matches is %2.")
-                .arg(atomid.toString()).arg(atms.count()), CODELOC);
+                                          "More than one atom matches '%1'. Number of matches is %2.")
+                                          .arg(atomid.toString())
+                                          .arg(atms.count()),
+                                      CODELOC);
 
     BOOST_ASSERT(not atms.isEmpty());
 
     return atms[0];
 }
 
-Residue SelectorMol::residue(int i, const PropertyMap&) const
+Residue SelectorMol::residue(int i, const PropertyMap &) const
 {
     i = Index(i).map(this->nResidues());
 
@@ -793,8 +857,10 @@ Residue SelectorMol::residue(const QString &name,
 
     if (res.count() > 1)
         throw SireMol::duplicate_residue(QObject::tr(
-            "More than one residue matches the name '%1'. Number of matches is %2.")
-                .arg(name).arg(res.count()), CODELOC);
+                                             "More than one residue matches the name '%1'. Number of matches is %2.")
+                                             .arg(name)
+                                             .arg(res.count()),
+                                         CODELOC);
 
     BOOST_ASSERT(not res.isEmpty());
 
@@ -808,15 +874,17 @@ Residue SelectorMol::residue(const ResID &resid,
 
     if (res.count() > 1)
         throw SireMol::duplicate_residue(QObject::tr(
-            "More than one residue matches '%1'. Number of matches is %2.")
-                .arg(resid.toString()).arg(res.count()), CODELOC);
+                                             "More than one residue matches '%1'. Number of matches is %2.")
+                                             .arg(resid.toString())
+                                             .arg(res.count()),
+                                         CODELOC);
 
     BOOST_ASSERT(not res.isEmpty());
 
     return res[0];
 }
 
-Chain SelectorMol::chain(int i, const PropertyMap&) const
+Chain SelectorMol::chain(int i, const PropertyMap &) const
 {
     i = Index(i).map(this->nChains());
 
@@ -840,8 +908,10 @@ Chain SelectorMol::chain(const QString &name,
 
     if (cs.count() > 1)
         throw SireMol::duplicate_chain(QObject::tr(
-            "More than one chain matches the name '%1'. Number of matches is %2.")
-                .arg(name).arg(cs.count()), CODELOC);
+                                           "More than one chain matches the name '%1'. Number of matches is %2.")
+                                           .arg(name)
+                                           .arg(cs.count()),
+                                       CODELOC);
 
     BOOST_ASSERT(not cs.isEmpty());
 
@@ -855,15 +925,17 @@ Chain SelectorMol::chain(const ChainID &chainid,
 
     if (cs.count() > 1)
         throw SireMol::duplicate_chain(QObject::tr(
-            "More than one chain matches '%1'. Number of matches is %2.")
-                .arg(chainid.toString()).arg(cs.count()), CODELOC);
+                                           "More than one chain matches '%1'. Number of matches is %2.")
+                                           .arg(chainid.toString())
+                                           .arg(cs.count()),
+                                       CODELOC);
 
     BOOST_ASSERT(not cs.isEmpty());
 
     return cs[0];
 }
 
-Segment SelectorMol::segment(int i, const PropertyMap&) const
+Segment SelectorMol::segment(int i, const PropertyMap &) const
 {
     i = Index(i).map(this->nSegments());
 
@@ -887,8 +959,10 @@ Segment SelectorMol::segment(const QString &name,
 
     if (segs.count() > 1)
         throw SireMol::duplicate_segment(QObject::tr(
-            "More than one segment matches the name '%1'. Number of matches is %2.")
-                .arg(name).arg(segs.count()), CODELOC);
+                                             "More than one segment matches the name '%1'. Number of matches is %2.")
+                                             .arg(name)
+                                             .arg(segs.count()),
+                                         CODELOC);
 
     BOOST_ASSERT(not segs.isEmpty());
 
@@ -902,15 +976,17 @@ Segment SelectorMol::segment(const SegID &segid,
 
     if (segs.count() > 1)
         throw SireMol::duplicate_segment(QObject::tr(
-            "More than one segment matches '%1'. Number of matches is %2.")
-                .arg(segid.toString()).arg(segs.count()), CODELOC);
+                                             "More than one segment matches '%1'. Number of matches is %2.")
+                                             .arg(segid.toString())
+                                             .arg(segs.count()),
+                                         CODELOC);
 
     BOOST_ASSERT(not segs.isEmpty());
 
     return segs[0];
 }
 
-CutGroup SelectorMol::cutGroup(int i, const PropertyMap&) const
+CutGroup SelectorMol::cutGroup(int i, const PropertyMap &) const
 {
     i = Index(i).map(this->nCutGroups());
 
@@ -934,8 +1010,10 @@ CutGroup SelectorMol::cutGroup(const QString &name,
 
     if (cgs.count() > 1)
         throw SireMol::duplicate_cutgroup(QObject::tr(
-            "More than one CutGroup matches the name '%1'. Number of matches is %2.")
-                .arg(name).arg(cgs.count()), CODELOC);
+                                              "More than one CutGroup matches the name '%1'. Number of matches is %2.")
+                                              .arg(name)
+                                              .arg(cgs.count()),
+                                          CODELOC);
 
     BOOST_ASSERT(not cgs.isEmpty());
 
@@ -949,8 +1027,10 @@ CutGroup SelectorMol::cutGroup(const CGID &cgid,
 
     if (cgs.count() > 1)
         throw SireMol::duplicate_cutgroup(QObject::tr(
-            "More than one CutGroup matches '%1'. Number of matches is %2.")
-                .arg(cgid.toString()).arg(cgs.count()), CODELOC);
+                                              "More than one CutGroup matches '%1'. Number of matches is %2.")
+                                              .arg(cgid.toString())
+                                              .arg(cgs.count()),
+                                          CODELOC);
 
     BOOST_ASSERT(not cgs.isEmpty());
 
@@ -968,13 +1048,13 @@ SelectorM<Atom> SelectorMol::atoms(int i, const PropertyMap &map) const
 }
 
 SelectorM<Atom> SelectorMol::atoms(const SireBase::Slice &slice,
-                                   const PropertyMap&) const
+                                   const PropertyMap &) const
 {
     return SelectorM<Atom>(*this, slice);
 }
 
 SelectorM<Atom> SelectorMol::atoms(const QList<qint64> &idxs,
-                                   const PropertyMap&) const
+                                   const PropertyMap &) const
 {
     return SelectorM<Atom>(*this, idxs);
 }
@@ -986,7 +1066,7 @@ SelectorM<Atom> SelectorMol::atoms(const QString &name,
 }
 
 SelectorM<Atom> SelectorMol::atoms(const AtomID &atomid,
-                                   const PropertyMap&) const
+                                   const PropertyMap &) const
 {
     return SelectorM<Atom>(*this, atomid);
 }
@@ -1002,13 +1082,13 @@ SelectorM<Residue> SelectorMol::residues(int i, const PropertyMap &map) const
 }
 
 SelectorM<Residue> SelectorMol::residues(const SireBase::Slice &slice,
-                                         const PropertyMap&) const
+                                         const PropertyMap &) const
 {
     return SelectorM<Residue>(*this, slice);
 }
 
 SelectorM<Residue> SelectorMol::residues(const QList<qint64> &idxs,
-                                         const PropertyMap&) const
+                                         const PropertyMap &) const
 {
     return SelectorM<Residue>(*this, idxs);
 }
@@ -1020,7 +1100,7 @@ SelectorM<Residue> SelectorMol::residues(const QString &name,
 }
 
 SelectorM<Residue> SelectorMol::residues(const ResID &resid,
-                                         const PropertyMap&) const
+                                         const PropertyMap &) const
 {
     return SelectorM<Residue>(*this, resid);
 }
@@ -1037,13 +1117,13 @@ SelectorM<Chain> SelectorMol::chains(int i,
 }
 
 SelectorM<Chain> SelectorMol::chains(const SireBase::Slice &slice,
-                                     const PropertyMap&) const
+                                     const PropertyMap &) const
 {
     return SelectorM<Chain>(*this, slice);
 }
 
 SelectorM<Chain> SelectorMol::chains(const QList<qint64> &idxs,
-                                     const PropertyMap&) const
+                                     const PropertyMap &) const
 {
     return SelectorM<Chain>(*this, idxs);
 }
@@ -1055,7 +1135,7 @@ SelectorM<Chain> SelectorMol::chains(const QString &name,
 }
 
 SelectorM<Chain> SelectorMol::chains(const ChainID &chainid,
-                                     const PropertyMap&) const
+                                     const PropertyMap &) const
 {
     return SelectorM<Chain>(*this, chainid);
 }
@@ -1072,13 +1152,13 @@ SelectorM<Segment> SelectorMol::segments(int i,
 }
 
 SelectorM<Segment> SelectorMol::segments(const SireBase::Slice &slice,
-                                         const PropertyMap&) const
+                                         const PropertyMap &) const
 {
     return SelectorM<Segment>(*this, slice);
 }
 
 SelectorM<Segment> SelectorMol::segments(const QList<qint64> &idxs,
-                                         const PropertyMap&) const
+                                         const PropertyMap &) const
 {
     return SelectorM<Segment>(*this, idxs);
 }
@@ -1090,7 +1170,7 @@ SelectorM<Segment> SelectorMol::segments(const QString &name,
 }
 
 SelectorM<Segment> SelectorMol::segments(const SegID &segid,
-                                         const PropertyMap&) const
+                                         const PropertyMap &) const
 {
     return SelectorM<Segment>(*this, segid);
 }
@@ -1107,13 +1187,13 @@ SelectorM<CutGroup> SelectorMol::cutGroups(int i,
 }
 
 SelectorM<CutGroup> SelectorMol::cutGroups(const SireBase::Slice &slice,
-                                           const PropertyMap&) const
+                                           const PropertyMap &) const
 {
     return SelectorM<CutGroup>(*this, slice);
 }
 
 SelectorM<CutGroup> SelectorMol::cutGroups(const QList<qint64> &idxs,
-                                           const PropertyMap&) const
+                                           const PropertyMap &) const
 {
     return SelectorM<CutGroup>(*this, idxs);
 }
@@ -1125,7 +1205,7 @@ SelectorM<CutGroup> SelectorMol::cutGroups(const QString &name,
 }
 
 SelectorM<CutGroup> SelectorMol::cutGroups(const CGID &cgid,
-                                           const PropertyMap&) const
+                                           const PropertyMap &) const
 {
     return SelectorM<CutGroup>(*this, cgid);
 }
@@ -1159,7 +1239,7 @@ QList<MolIdx> SelectorMol::indexes() const
     QList<MolIdx> idxs;
     idxs.reserve(this->mols.count());
 
-    for (int i=0; i<this->mols.count(); ++i)
+    for (int i = 0; i < this->mols.count(); ++i)
     {
         idxs.append(MolIdx(i));
     }
@@ -1353,35 +1433,32 @@ QString SelectorMol::toString() const
 
         if (n <= 10)
         {
-            for (int i=0; i<n; ++i)
+            for (int i = 0; i < n; ++i)
             {
-                parts.append(QObject::tr("%1: %2").arg(i)
-                                        .arg(this->mols[i].toString()));
+                parts.append(QObject::tr("%1: %2").arg(i).arg(this->mols[i].toString()));
             }
         }
         else
         {
-            for (int i=0; i<5; ++i)
+            for (int i = 0; i < 5; ++i)
             {
-                parts.append(QObject::tr("%1: %2").arg(i)
-                                        .arg(this->mols[i].toString()));
+                parts.append(QObject::tr("%1: %2").arg(i).arg(this->mols[i].toString()));
             }
 
             parts.append("...");
 
-            for (int i=n-5; i<n; ++i)
+            for (int i = n - 5; i < n; ++i)
             {
-                parts.append(QObject::tr("%1: %2").arg(i)
-                                        .arg(this->mols[i].toString()));
+                parts.append(QObject::tr("%1: %2").arg(i).arg(this->mols[i].toString()));
             }
         }
 
         return QObject::tr("SelectorMol( size=%1\n%2\n)")
-                        .arg(n).arg(parts.join("\n"));
+            .arg(n)
+            .arg(parts.join("\n"));
     }
 }
 
-
 namespace SireMol
 {
     template class SelectorM<Atom>;
diff --git a/corelib/src/libs/SireMol/selectormol.h b/corelib/src/libs/SireMol/selectormol.h
index 757d66dfb..30fff4985 100644
--- a/corelib/src/libs/SireMol/selectormol.h
+++ b/corelib/src/libs/SireMol/selectormol.h
@@ -47,7 +47,7 @@ namespace SireMol
     class SelectorMol;
     class EvaluatorM;
 
-    template<class T>
+    template <class T>
     class SelectorM;
 
     class Molecules;
@@ -66,263 +66,266 @@ namespace SireMol
     class MolIdx;
 }
 
-SIREMOL_EXPORT QDataStream& operator<<(QDataStream&, const SireMol::SelectorMol&);
-SIREMOL_EXPORT QDataStream& operator>>(QDataStream&, SireMol::SelectorMol&);
+SIREMOL_EXPORT QDataStream &operator<<(QDataStream &, const SireMol::SelectorMol &);
+SIREMOL_EXPORT QDataStream &operator>>(QDataStream &, SireMol::SelectorMol &);
 
 namespace SireMol
 {
 
-/** This class provides a Selector<T>-type interface to a
-    collection of molecules.
-*/
-class SIREMOL_EXPORT SelectorMol
-    : public SireBase::ConcreteProperty<SelectorMol,SireBase::Property>
-{
+    /** This class provides a Selector<T>-type interface to a
+        collection of molecules.
+    */
+    class SIREMOL_EXPORT SelectorMol
+        : public SireBase::ConcreteProperty<SelectorMol, SireBase::Property>
+    {
 
-friend SIREMOL_EXPORT QDataStream& ::operator<<(QDataStream&, const SelectorMol&);
-friend SIREMOL_EXPORT QDataStream& ::operator>>(QDataStream&, SelectorMol&);
+        friend SIREMOL_EXPORT QDataStream & ::operator<<(QDataStream &, const SelectorMol &);
+        friend SIREMOL_EXPORT QDataStream & ::operator>>(QDataStream &, SelectorMol &);
 
-public:
-    typedef QList<Molecule>::const_iterator const_iterator;
-    typedef QList<Molecule>::const_iterator iterator;
+    public:
+        typedef QList<Molecule>::const_iterator const_iterator;
+        typedef QList<Molecule>::const_iterator iterator;
 
-    SelectorMol();
-    SelectorMol(const MoleculeView &mol);
-    SelectorMol(const Molecules &mols);
-    SelectorMol(const MoleculeGroup &mols);
-    SelectorMol(const MolGroupsBase &mols);
-    SelectorMol(const SelectResult &mols);
+        SelectorMol();
+        SelectorMol(const MoleculeView &mol);
+        SelectorMol(const Molecules &mols);
+        SelectorMol(const MoleculeGroup &mols);
+        SelectorMol(const MolGroupsBase &mols);
+        SelectorMol(const SelectResult &mols);
 
-    template<class T>
-    SelectorMol(const SelectorM<T> &other);
-    template<class T>
-    SelectorMol(const SelectorM<T> &other, const QString &name,
-                const SireBase::PropertyMap &map = SireBase::PropertyMap());
-    template<class T>
-    SelectorMol(const SelectorM<T> &other, const SireBase::Slice &slice);
-    template<class T>
-    SelectorMol(const SelectorM<T> &other, const QList<qint64> &idxs);
-    template<class T>
-    SelectorMol(const SelectorM<T> &other, const MolID &molid);
+        template <class T>
+        SelectorMol(const SelectorM<T> &other);
+        template <class T>
+        SelectorMol(const SelectorM<T> &other, const QString &name,
+                    const SireBase::PropertyMap &map = SireBase::PropertyMap());
+        template <class T>
+        SelectorMol(const SelectorM<T> &other, const SireBase::Slice &slice);
+        template <class T>
+        SelectorMol(const SelectorM<T> &other, const QList<qint64> &idxs);
+        template <class T>
+        SelectorMol(const SelectorM<T> &other, const MolID &molid);
 
-    SelectorMol(const SelectorMol &other);
+        SelectorMol(const SelectorMol &other);
 
-    virtual ~SelectorMol();
+        virtual ~SelectorMol();
 
-    static const char* typeName();
+        static const char *typeName();
 
-    virtual const char* what() const
-    {
-        return SelectorMol::typeName();
-    }
+        virtual const char *what() const
+        {
+            return SelectorMol::typeName();
+        }
 
-    virtual SelectorMol* clone() const
-    {
-        return new SelectorMol(*this);
-    }
+        virtual SelectorMol *clone() const
+        {
+            return new SelectorMol(*this);
+        }
 
-    SelectorMol& operator=(const SelectorMol &other);
+        SelectorMol &operator=(const SelectorMol &other);
 
-    bool operator==(const SelectorMol &other) const;
-    bool operator!=(const SelectorMol &other) const;
+        bool operator==(const SelectorMol &other) const;
+        bool operator!=(const SelectorMol &other) const;
 
-    Molecule operator[](int i) const;
-    SelectorMol operator[](const SireBase::Slice &slice) const;
-    SelectorMol operator[](const QList<qint64> &idxs) const;
-    Molecule operator[](const QString &name) const;
-    Molecule operator[](const MolIdx &molidx) const;
-    Molecule operator[](const MolName &molname) const;
-    Molecule operator[](const MolNum &molnum) const;
-    Molecule operator[](const MolID &molid) const;
+        Molecule operator[](int i) const;
+        SelectorMol operator[](const SireBase::Slice &slice) const;
+        SelectorMol operator[](const QList<qint64> &idxs) const;
+        Molecule operator[](const QString &name) const;
+        Molecule operator[](const MolIdx &molidx) const;
+        Molecule operator[](const MolName &molname) const;
+        Molecule operator[](const MolNum &molnum) const;
+        Molecule operator[](const MolID &molid) const;
 
-    QList<MolViewPtr> toList() const;
-    Molecules toMolecules() const;
+        QList<MolViewPtr> toList() const;
+        Molecules toMolecules() const;
 
-    int count() const;
-    int size() const;
+        int count() const;
+        int size() const;
 
-    void update(const Molecules &molecules);
+        void update(const Molecules &molecules);
 
-    EvaluatorM evaluate() const;
+        EvaluatorM evaluate() const;
 
-    MoleculeGroup toMoleculeGroup() const;
-    SelectResult toSelectResult() const;
+        MoleculeGroup toMoleculeGroup() const;
+        SelectResult toSelectResult() const;
 
-    bool isSelector() const;
+        bool isSelector() const;
 
-    Molecule molecule(int i,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Molecule molecule(const QString &name,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Molecule molecule(const MolIdx &molidx,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Molecule molecule(const MolName &molname,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Molecule molecule(const MolNum &molnum,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    Molecule molecule(const MolID &molid,
-                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        QList<qint64> find(const Molecule &view) const;
+        QList<qint64> find(const SelectorMol &views) const;
 
-    SelectorMol molecules() const;
-    SelectorMol molecules(int i,
+        Molecule molecule(int i,
                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const SireBase::Slice &slice,
+        Molecule molecule(const QString &name,
                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const QList<qint64> &idxs,
+        Molecule molecule(const MolIdx &molidx,
                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const QString &name,
+        Molecule molecule(const MolName &molname,
                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const MolIdx &molidx,
+        Molecule molecule(const MolNum &molnum,
                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const MolName &molname,
+        Molecule molecule(const MolID &molid,
+                          const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectorMol molecules() const;
+        SelectorMol molecules(int i,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const SireBase::Slice &slice,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const QList<qint64> &idxs,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const QString &name,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const MolIdx &molidx,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const MolName &molname,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const MolNum &molnum,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorMol molecules(const MolID &molid,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        bool contains(const MolNum &molnum) const;
+
+        Atom atom(int i,
+                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Atom atom(const QString &name,
+                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Atom atom(const AtomID &atomid,
+                  const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        Residue residue(int i,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Residue residue(const QString &name,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Residue residue(const ResID &resid,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        Chain chain(int i,
+                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Chain chain(const QString &name,
+                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Chain chain(const ChainID &chainid,
+                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        Segment segment(int i,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Segment segment(const QString &name,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        Segment segment(const SegID &segid,
+                        const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        CutGroup cutGroup(int i,
                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const MolNum &molnum,
+        CutGroup cutGroup(const QString &name,
                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
-    SelectorMol molecules(const MolID &molid,
+        CutGroup cutGroup(const CGID &cgid,
                           const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
 
-    bool contains(const MolNum &molnum) const;
-
-    Atom atom(int i,
-              const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Atom atom(const QString &name,
-              const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Atom atom(const AtomID &atomid,
-              const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    Residue residue(int i,
-                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Residue residue(const QString &name,
-                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Residue residue(const ResID &resid,
-                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    Chain chain(int i,
-                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Chain chain(const QString &name,
-                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Chain chain(const ChainID &chainid,
-                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    Segment segment(int i,
-                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Segment segment(const QString &name,
-                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    Segment segment(const SegID &segid,
-                    const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    CutGroup cutGroup(int i,
-                      const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    CutGroup cutGroup(const QString &name,
-                      const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    CutGroup cutGroup(const CGID &cgid,
-                      const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectorM<Atom> atoms() const;
-    SelectorM<Atom> atoms(int i,
-                          const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Atom> atoms(const SireBase::Slice &slice,
-                          const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Atom> atoms(const QList<qint64> &idxs,
-                          const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Atom> atoms(const QString &name,
-                          const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Atom> atoms(const AtomID &atomid,
-                          const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectorM<Residue> residues() const;
-    SelectorM<Residue> residues(int i,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Residue> residues(const SireBase::Slice &slice,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Residue> residues(const QList<qint64> &idxs,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Residue> residues(const QString &name,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Residue> residues(const ResID &resid,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectorM<Chain> chains() const;
-    SelectorM<Chain> chains(int i,
-                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Chain> chains(const SireBase::Slice &slice,
-                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Chain> chains(const QList<qint64> &idxs,
-                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Chain> chains(const QString &name,
-                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Chain> chains(const ChainID &chainid,
-                            const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectorM<Segment> segments() const;
-    SelectorM<Segment> segments(int i,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Segment> segments(const SireBase::Slice &slice,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Segment> segments(const QList<qint64> &idxs,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Segment> segments(const QString &name,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<Segment> segments(const SegID &segid,
-                                const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectorM<CutGroup> cutGroups() const;
-    SelectorM<CutGroup> cutGroups(int i,
-                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<CutGroup> cutGroups(const SireBase::Slice &slice,
-                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<CutGroup> cutGroups(const QList<qint64> &idxs,
-                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<CutGroup> cutGroups(const QString &name,
-                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-    SelectorM<CutGroup> cutGroups(const CGID &cgid,
-                                  const SireBase::PropertyMap &map=SireBase::PropertyMap()) const;
-
-    SelectResult search(const QString &search_string) const;
-    SelectResult search(const QString &search_string,
-                        const SireBase::PropertyMap &map) const;
-
-    QVector<MolNum> molNums() const;
-
-    QList<MolNum> IDs() const;
-    QList<MolIdx> indexes() const;
-    QList<MolNum> numbers() const;
-    QList<MolName> names() const;
-
-    int nAtoms() const;
-    int nResidues() const;
-    int nChains() const;
-    int nSegments() const;
-    int nCutGroups() const;
-    int nMolecules() const;
-
-    bool isEmpty() const;
-
-    int nFrames() const;
-    int nFrames(const SireBase::PropertyMap &map) const;
-
-    void loadFrame(int frame);
-    void saveFrame(int frame);
-    void saveFrame();
-    void deleteFrame(int frame);
-
-    void loadFrame(int frame, const SireBase::PropertyMap &map);
-    void saveFrame(int frame, const SireBase::PropertyMap &map);
-    void saveFrame(const SireBase::PropertyMap &map);
-    void deleteFrame(int frame, const SireBase::PropertyMap &map);
-
-    const_iterator begin() const;
-    const_iterator end() const;
-
-    const_iterator constBegin() const;
-    const_iterator constEnd() const;
-
-    virtual QString toString() const;
-
-protected:
-    /** The actual list of molecules */
-    QList<Molecule> mols;
-};
+        SelectorM<Atom> atoms() const;
+        SelectorM<Atom> atoms(int i,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Atom> atoms(const SireBase::Slice &slice,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Atom> atoms(const QList<qint64> &idxs,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Atom> atoms(const QString &name,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Atom> atoms(const AtomID &atomid,
+                              const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectorM<Residue> residues() const;
+        SelectorM<Residue> residues(int i,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Residue> residues(const SireBase::Slice &slice,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Residue> residues(const QList<qint64> &idxs,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Residue> residues(const QString &name,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Residue> residues(const ResID &resid,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectorM<Chain> chains() const;
+        SelectorM<Chain> chains(int i,
+                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Chain> chains(const SireBase::Slice &slice,
+                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Chain> chains(const QList<qint64> &idxs,
+                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Chain> chains(const QString &name,
+                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Chain> chains(const ChainID &chainid,
+                                const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectorM<Segment> segments() const;
+        SelectorM<Segment> segments(int i,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Segment> segments(const SireBase::Slice &slice,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Segment> segments(const QList<qint64> &idxs,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Segment> segments(const QString &name,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<Segment> segments(const SegID &segid,
+                                    const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectorM<CutGroup> cutGroups() const;
+        SelectorM<CutGroup> cutGroups(int i,
+                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<CutGroup> cutGroups(const SireBase::Slice &slice,
+                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<CutGroup> cutGroups(const QList<qint64> &idxs,
+                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<CutGroup> cutGroups(const QString &name,
+                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+        SelectorM<CutGroup> cutGroups(const CGID &cgid,
+                                      const SireBase::PropertyMap &map = SireBase::PropertyMap()) const;
+
+        SelectResult search(const QString &search_string) const;
+        SelectResult search(const QString &search_string,
+                            const SireBase::PropertyMap &map) const;
+
+        QVector<MolNum> molNums() const;
+
+        QList<MolNum> IDs() const;
+        QList<MolIdx> indexes() const;
+        QList<MolNum> numbers() const;
+        QList<MolName> names() const;
+
+        int nAtoms() const;
+        int nResidues() const;
+        int nChains() const;
+        int nSegments() const;
+        int nCutGroups() const;
+        int nMolecules() const;
+
+        bool isEmpty() const;
+
+        int nFrames() const;
+        int nFrames(const SireBase::PropertyMap &map) const;
+
+        void loadFrame(int frame);
+        void saveFrame(int frame);
+        void saveFrame();
+        void deleteFrame(int frame);
+
+        void loadFrame(int frame, const SireBase::PropertyMap &map);
+        void saveFrame(int frame, const SireBase::PropertyMap &map);
+        void saveFrame(const SireBase::PropertyMap &map);
+        void deleteFrame(int frame, const SireBase::PropertyMap &map);
+
+        const_iterator begin() const;
+        const_iterator end() const;
+
+        const_iterator constBegin() const;
+        const_iterator constEnd() const;
+
+        virtual QString toString() const;
+
+    protected:
+        /** The actual list of molecules */
+        QList<Molecule> mols;
+    };
 
 }
 
@@ -335,11 +338,11 @@ Q_DECLARE_METATYPE(SireMol::SelectorM<SireMol::CutGroup>);
 
 SIRE_EXPOSE_CLASS(SireMol::SelectorMol)
 
-SIRE_EXPOSE_ALIAS( SireMol::SelectorM<SireMol::Atom>, SireMol::SelectorM_Atom_ )
-SIRE_EXPOSE_ALIAS( SireMol::SelectorM<SireMol::Residue>, SireMol::SelectorM_Residue_ )
-SIRE_EXPOSE_ALIAS( SireMol::SelectorM<SireMol::Chain>, SireMol::SelectorM_Chain_ )
-SIRE_EXPOSE_ALIAS( SireMol::SelectorM<SireMol::Segment>, SireMol::SelectorM_Segment_ )
-SIRE_EXPOSE_ALIAS( SireMol::SelectorM<SireMol::CutGroup>, SireMol::SelectorM_CutGroup_ )
+SIRE_EXPOSE_ALIAS(SireMol::SelectorM<SireMol::Atom>, SireMol::SelectorM_Atom_)
+SIRE_EXPOSE_ALIAS(SireMol::SelectorM<SireMol::Residue>, SireMol::SelectorM_Residue_)
+SIRE_EXPOSE_ALIAS(SireMol::SelectorM<SireMol::Chain>, SireMol::SelectorM_Chain_)
+SIRE_EXPOSE_ALIAS(SireMol::SelectorM<SireMol::Segment>, SireMol::SelectorM_Segment_)
+SIRE_EXPOSE_ALIAS(SireMol::SelectorM<SireMol::CutGroup>, SireMol::SelectorM_CutGroup_)
 
 // include this here so that SelectorM is always instantiatable if
 // SelectorMol has been included
@@ -350,61 +353,61 @@ SIRE_EXPOSE_ALIAS( SireMol::SelectorM<SireMol::CutGroup>, SireMol::SelectorM_Cut
 namespace SireMol
 {
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol::SelectorMol(const SelectorM<T> &other)
-            : SireBase::ConcreteProperty<SelectorMol,SireBase::Property>()
-{
-    if (not other.isEmpty())
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorMol::SelectorMol(const SelectorM<T> &other)
+        : SireBase::ConcreteProperty<SelectorMol, SireBase::Property>()
     {
-        this->mols.reserve(other.nMolecules());
-
-        for (int i=0; i<other.nMolecules(); ++i)
+        if (not other.isEmpty())
         {
-            this->mols.append(other.molecule(i));
+            this->mols.reserve(other.nMolecules());
+
+            for (int i = 0; i < other.nMolecules(); ++i)
+            {
+                this->mols.append(other.molecule(i));
+            }
         }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol::SelectorMol(const SelectorM<T> &other, const QString &name,
-                         const PropertyMap &map)
-            : SireBase::ConcreteProperty<SelectorMol,SireBase::Property>()
-{
-    this->operator=(SelectorMol(other).molecules(name, map));
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorMol::SelectorMol(const SelectorM<T> &other, const QString &name,
+                             const PropertyMap &map)
+        : SireBase::ConcreteProperty<SelectorMol, SireBase::Property>()
+    {
+        this->operator=(SelectorMol(other).molecules(name, map));
+    }
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol::SelectorMol(const SelectorM<T> &other, const SireBase::Slice &slice)
-            : SireBase::ConcreteProperty<SelectorMol,SireBase::Property>()
-{
-    for (auto it = slice.begin(other.nMolecules());
-         not it.atEnd(); it.next())
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorMol::SelectorMol(const SelectorM<T> &other, const SireBase::Slice &slice)
+        : SireBase::ConcreteProperty<SelectorMol, SireBase::Property>()
     {
-        this->mols.append(other.molecule(it.value()));
+        for (auto it = slice.begin(other.nMolecules());
+             not it.atEnd(); it.next())
+        {
+            this->mols.append(other.molecule(it.value()));
+        }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol::SelectorMol(const SelectorM<T> &other, const QList<qint64> &idxs)
-            : SireBase::ConcreteProperty<SelectorMol,SireBase::Property>()
-{
-    for (const auto &idx : idxs)
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorMol::SelectorMol(const SelectorM<T> &other, const QList<qint64> &idxs)
+        : SireBase::ConcreteProperty<SelectorMol, SireBase::Property>()
     {
-        this->mols.append(other.molecule(idx));
+        for (const auto &idx : idxs)
+        {
+            this->mols.append(other.molecule(idx));
+        }
     }
-}
 
-template<class T>
-SIRE_OUTOFLINE_TEMPLATE
-SelectorMol::SelectorMol(const SelectorM<T> &other, const MolID &molid)
-            : SireBase::ConcreteProperty<SelectorMol,SireBase::Property>()
-{
-    this->operator=(other.molecules().molecules(molid));
-}
+    template <class T>
+    SIRE_OUTOFLINE_TEMPLATE
+    SelectorMol::SelectorMol(const SelectorM<T> &other, const MolID &molid)
+        : SireBase::ConcreteProperty<SelectorMol, SireBase::Property>()
+    {
+        this->operator=(other.molecules().molecules(molid));
+    }
 
 } // end of namespace SireMol
 
@@ -420,7 +423,7 @@ template class SireMol::SelectorM<SireMol::Chain>;
 template class SireMol::SelectorM<SireMol::Segment>;
 template class SireMol::SelectorM<SireMol::CutGroup>;
 
-#endif //SIRE_INSTANTIATE_TEMPLATES
+#endif // SIRE_INSTANTIATE_TEMPLATES
 
 SIRE_END_HEADER
 
diff --git a/corelib/src/libs/SireMove/ensemble.cpp b/corelib/src/libs/SireMove/ensemble.cpp
index a6d6f0a59..d77020b74 100644
--- a/corelib/src/libs/SireMove/ensemble.cpp
+++ b/corelib/src/libs/SireMove/ensemble.cpp
@@ -49,10 +49,10 @@ using namespace SireMove::detail;
 
 static const RegisterMetaType<Ensemble> r_ensemble;
 
-template<class T>
-static QDataStream& operator<<(QDataStream &ds, const CharArray<T> &array)
+template <class T>
+static QDataStream &operator<<(QDataStream &ds, const CharArray<T> &array)
 {
-    for (int i=0; i<CharArray<T>::count(); ++i)
+    for (int i = 0; i < CharArray<T>::count(); ++i)
     {
         ds << array[i];
     }
@@ -60,10 +60,10 @@ static QDataStream& operator<<(QDataStream &ds, const CharArray<T> &array)
     return ds;
 }
 
-template<class T>
-static QDataStream& operator>>(QDataStream &ds, CharArray<T> &array)
+template <class T>
+static QDataStream &operator>>(QDataStream &ds, CharArray<T> &array)
 {
-    for (int i=0; i<CharArray<T>::count(); ++i)
+    for (int i = 0; i < CharArray<T>::count(); ++i)
     {
         ds >> array[i];
     }
@@ -80,7 +80,7 @@ QDataStream &operator<<(QDataStream &ds, const Ensemble &ensemble)
        << double(ensemble.ensemble_pressure)
        << double(ensemble.ensemble_fugacity)
        << ensemble.ensemble_state
-       << static_cast<const Property&>(ensemble);
+       << static_cast<const Property &>(ensemble);
 
     return ds;
 }
@@ -94,30 +94,28 @@ QDataStream &operator>>(QDataStream &ds, Ensemble &ensemble)
     {
         double temp, press, fug;
 
-        ds >> temp >> press >> fug
-           >> ensemble.ensemble_state
-           >> static_cast<Property&>(ensemble);
+        ds >> temp >> press >> fug >> ensemble.ensemble_state >> static_cast<Property &>(ensemble);
 
         ensemble.ensemble_temperature = Temperature(temp);
         ensemble.ensemble_pressure = Pressure(press);
         ensemble.ensemble_fugacity = Pressure(fug);
     }
     else
-        throw version_error( v, "1", r_ensemble, CODELOC );
+        throw version_error(v, "1", r_ensemble, CODELOC);
 
     return ds;
 }
 
 static const quint8 UNKNOWN = 0; // unknown state
 
-static const quint8 N = 4;       // constant number of particles
-static const quint8 Mu = 16;     // constant chemical potential
+static const quint8 N = 4;   // constant number of particles
+static const quint8 Mu = 16; // constant chemical potential
 
-static const quint8 V = 4;       // constant volume
-static const quint8 P = 16;      // constant pressure
+static const quint8 V = 4;  // constant volume
+static const quint8 P = 16; // constant pressure
 
-static const quint8 E = 4;       // constant total energy
-static const quint8 T = 16;      // constant temperature
+static const quint8 E = 4;  // constant total energy
+static const quint8 T = 16; // constant temperature
 
 /** Return the description for the passed state parameters */
 static CharArray<quint32> getDescription(quint8 n, quint8 v, quint8 t)
@@ -132,15 +130,15 @@ static CharArray<quint32> getDescription(quint8 n, quint8 v, quint8 t)
 }
 
 /** Return the merged version of the passed two states */
-template<class T>
+template <class T>
 static CharArray<T> merge(const CharArray<T> &des0,
                           const CharArray<T> &des1)
 {
     CharArray<T> merged;
 
-    for (int i=0; i<CharArray<T>::count(); ++i)
+    for (int i = 0; i < CharArray<T>::count(); ++i)
     {
-        merged[i] = qMax( des0[i], des1[i] );
+        merged[i] = qMax(des0[i], des1[i]);
     }
 
     return merged;
@@ -148,26 +146,28 @@ static CharArray<T> merge(const CharArray<T> &des0,
 
 /** Construct an NVE ensemble */
 Ensemble::Ensemble()
-         : ensemble_temperature(0), ensemble_pressure(0),
-           ensemble_fugacity(0)
+    : ensemble_temperature(0), ensemble_pressure(0),
+      ensemble_fugacity(0)
 {
-    ensemble_state = getDescription( N, V, E );
+    ensemble_state = getDescription(N, V, E);
 }
 
 /** Copy constructor */
 Ensemble::Ensemble(const Ensemble &other)
-         : ensemble_temperature(other.ensemble_temperature),
-           ensemble_pressure(other.ensemble_pressure),
-           ensemble_fugacity(other.ensemble_fugacity),
-           ensemble_state(other.ensemble_state)
-{}
+    : ensemble_temperature(other.ensemble_temperature),
+      ensemble_pressure(other.ensemble_pressure),
+      ensemble_fugacity(other.ensemble_fugacity),
+      ensemble_state(other.ensemble_state)
+{
+}
 
 /** Destructor */
 Ensemble::~Ensemble()
-{}
+{
+}
 
 /** Copy assignment operator */
-Ensemble& Ensemble::operator=(const Ensemble &other)
+Ensemble &Ensemble::operator=(const Ensemble &other)
 {
     if (this != &other)
     {
@@ -240,25 +240,25 @@ bool Ensemble::isConstantChemicalPotential() const
 /** Return whether or not this is the NVE ensemble */
 bool Ensemble::isNVE() const
 {
-    return ensemble_state == getDescription( N, V, E );
+    return ensemble_state == getDescription(N, V, E);
 }
 
 /** Return whether or not this is the NVT ensemble */
 bool Ensemble::isNVT() const
 {
-    return ensemble_state == getDescription( N, V, T );
+    return ensemble_state == getDescription(N, V, T);
 }
 
 /** Return whether or not this is the NPT ensemble */
 bool Ensemble::isNPT() const
 {
-    return ensemble_state == getDescription( N, P, T );
+    return ensemble_state == getDescription(N, P, T);
 }
 
 /** Return whether or not this is the MuVT ensemble */
 bool Ensemble::isMuVT() const
 {
-    return ensemble_state == getDescription( Mu, V, T );
+    return ensemble_state == getDescription(Mu, V, T);
 }
 
 /** Return whether or not this is the microcanonical (NVE) ensemble */
@@ -292,41 +292,41 @@ QString Ensemble::shortHand() const
 
     switch (ensemble_state[0])
     {
-        case N:
-            shorthand[0] = 'N';
-            break;
-        case Mu:
-            shorthand[0] = 'M';   // #warning Need greek Mu character
-            break;
-        default:
-            shorthand[0] = '?';
-            break;
+    case N:
+        shorthand[0] = 'N';
+        break;
+    case Mu:
+        shorthand[0] = 'M'; // #warning Need greek Mu character
+        break;
+    default:
+        shorthand[0] = '?';
+        break;
     }
 
     switch (ensemble_state[1])
     {
-        case V:
-            shorthand[1] = 'V';
-            break;
-        case P:
-            shorthand[1] = 'P';
-            break;
-        default:
-            shorthand[1] = '?';
-            break;
+    case V:
+        shorthand[1] = 'V';
+        break;
+    case P:
+        shorthand[1] = 'P';
+        break;
+    default:
+        shorthand[1] = '?';
+        break;
     }
 
     switch (ensemble_state[2])
     {
-        case E:
-            shorthand[2] = 'E';
-            break;
-        case T:
-            shorthand[2] = 'T';
-            break;
-        default:
-            shorthand[2] = '?';
-            break;
+    case E:
+        shorthand[2] = 'E';
+        break;
+    case T:
+        shorthand[2] = 'T';
+        break;
+    default:
+        shorthand[2] = '?';
+        break;
     }
 
     return shorthand;
@@ -358,20 +358,20 @@ QString Ensemble::toString() const
 
     if (this->isConstantChemicalPotential())
     {
-        parts.append( QObject::tr("chemical potential = %1 kcal mol-1")
-                            .arg( this->chemicalPotential().to(kcal_per_mol) ) );
+        parts.append(QObject::tr("chemical potential = %1 kcal mol-1")
+                         .arg(this->chemicalPotential().to(kcal_per_mol)));
     }
 
     if (this->isConstantPressure())
     {
-        parts.append( QObject::tr("pressure = %1 atm")
-                            .arg( this->pressure().to(atm) ) );
+        parts.append(QObject::tr("pressure = %1 atm")
+                         .arg(this->pressure().to(atm)));
     }
 
     if (this->isConstantTemperature())
     {
-        parts.append( QObject::tr("temperature = %1 C")
-                            .arg( this->temperature().to(Celsius()) ) );
+        parts.append(QObject::tr("temperature = %1 C")
+                         .arg(this->temperature().to(Celsius())));
     }
 
     if (parts.isEmpty())
@@ -379,7 +379,7 @@ QString Ensemble::toString() const
 
     else
         return QString("%1 { %2 }")
-                    .arg(this->name(), Sire::toString(parts));
+            .arg(this->name(), Sire::toString(parts));
 }
 
 /** Return the temperature of this ensemble
@@ -389,9 +389,10 @@ QString Ensemble::toString() const
 Temperature Ensemble::temperature() const
 {
     if (not this->isConstantTemperature())
-        throw SireError::incompatible_error( QObject::tr(
-            "The %1 ensemble does not have a constant temperature.")
-                .arg(this->shortHand()), CODELOC );
+        throw SireError::incompatible_error(QObject::tr(
+                                                "The %1 ensemble does not have a constant temperature.")
+                                                .arg(this->shortHand()),
+                                            CODELOC);
 
     return ensemble_temperature;
 }
@@ -403,9 +404,10 @@ Temperature Ensemble::temperature() const
 Pressure Ensemble::pressure() const
 {
     if (not this->isConstantPressure())
-        throw SireError::incompatible_error( QObject::tr(
-            "The %1 ensemble does not have a constant pressure.")
-                .arg(this->shortHand()), CODELOC );
+        throw SireError::incompatible_error(QObject::tr(
+                                                "The %1 ensemble does not have a constant pressure.")
+                                                .arg(this->shortHand()),
+                                            CODELOC);
 
     return ensemble_pressure;
 }
@@ -417,9 +419,10 @@ Pressure Ensemble::pressure() const
 Pressure Ensemble::fugacity() const
 {
     if (not this->isConstantFugacity())
-        throw SireError::incompatible_error( QObject::tr(
-            "The %1 ensemble does not have a constant fugacity.")
-                .arg(this->shortHand()), CODELOC );
+        throw SireError::incompatible_error(QObject::tr(
+                                                "The %1 ensemble does not have a constant fugacity.")
+                                                .arg(this->shortHand()),
+                                            CODELOC);
 
     return ensemble_fugacity;
 }
@@ -431,9 +434,10 @@ Pressure Ensemble::fugacity() const
 MolarEnergy Ensemble::chemicalPotential() const
 {
     if (not this->isConstantChemicalPotential())
-        throw SireError::incompatible_error( QObject::tr(
-            "The %1 ensemble does not have a constant chemical potential.")
-                .arg(this->shortHand()), CODELOC );
+        throw SireError::incompatible_error(QObject::tr(
+                                                "The %1 ensemble does not have a constant chemical potential.")
+                                                .arg(this->shortHand()),
+                                            CODELOC);
 
     // mu = mu_0 + RT ln ( f / P_0 )
     //
@@ -443,8 +447,7 @@ MolarEnergy Ensemble::chemicalPotential() const
     //  where P_0 is 1 bar (standard state)
 
     // we will actually return mu - mu_0  == RT ln (f / P_0 )
-    return MolarEnergy( gasr * ensemble_temperature.value()
-                             * std::log( ensemble_fugacity / 1.0*bar ) );
+    return MolarEnergy(gasr * ensemble_temperature.value() * std::log(ensemble_fugacity / 1.0 * bar));
 }
 
 /** Merge the two ensembles 'e0' and 'e1' together. This tries to find an ensemble
@@ -570,8 +573,8 @@ Ensemble Ensemble::MuVT(const Temperature &temperature,
 
     // we will actually use mu - mu_0  == RT ln (f / P_0 )
     // so chemical potential = mu - mu_0
-    return Ensemble::MuVT( temperature,
-                           std::exp( chemical_potential / (gasr*temperature) ) * bar );
+    return Ensemble::MuVT(temperature,
+                          std::exp(chemical_potential / (gasr.value() * temperature)) * bar);
 }
 
 /** Syntactic sugar to return the NVE ensemble */
@@ -607,12 +610,12 @@ Ensemble Ensemble::grandCanonical(const Temperature &temperature,
     return Ensemble::MuVT(temperature, chemical_potential);
 }
 
-const char* Ensemble::typeName()
+const char *Ensemble::typeName()
 {
-    return QMetaType::typeName( qMetaTypeId<Ensemble>() );
+    return QMetaType::typeName(qMetaTypeId<Ensemble>());
 }
 
-Ensemble* Ensemble::clone() const
+Ensemble *Ensemble::clone() const
 {
     return new Ensemble(*this);
 }
diff --git a/corelib/src/libs/SireMove/moleculardynamics.cpp b/corelib/src/libs/SireMove/moleculardynamics.cpp
index fe9c1b390..7b59afad1 100644
--- a/corelib/src/libs/SireMove/moleculardynamics.cpp
+++ b/corelib/src/libs/SireMove/moleculardynamics.cpp
@@ -53,7 +53,7 @@ static const RegisterMetaType<MolecularDynamics> r_moldyn;
 
 /** Serialise to a binary datastream */
 QDataStream &operator<<(QDataStream &ds,
-                                        const MolecularDynamics &moldyn)
+                        const MolecularDynamics &moldyn)
 {
     writeHeader(ds, r_moldyn, 1);
 
@@ -61,14 +61,14 @@ QDataStream &operator<<(QDataStream &ds,
 
     sds << moldyn.intgrator << moldyn.wspace << moldyn.timestep << moldyn.num_moves
         << moldyn.total_time
-        << static_cast<const Dynamics&>(moldyn);
+        << static_cast<const Dynamics &>(moldyn);
 
     return ds;
 }
 
 /** Extract from a binary datastream */
 QDataStream &operator>>(QDataStream &ds,
-                                        MolecularDynamics &moldyn)
+                        MolecularDynamics &moldyn)
 {
     VersionID v = readHeader(ds, r_moldyn);
 
@@ -76,10 +76,7 @@ QDataStream &operator>>(QDataStream &ds,
     {
         SharedDataStream sds(ds);
 
-        sds >> moldyn.intgrator >> moldyn.wspace >> moldyn.timestep
-            >> moldyn.num_moves >> moldyn.total_time
-            >> static_cast<Dynamics&>(moldyn);
-
+        sds >> moldyn.intgrator >> moldyn.wspace >> moldyn.timestep >> moldyn.num_moves >> moldyn.total_time >> static_cast<Dynamics &>(moldyn);
     }
     else
         throw version_error(v, "1", r_moldyn, CODELOC);
@@ -89,25 +86,25 @@ QDataStream &operator>>(QDataStream &ds,
 
 /** Constructor */
 MolecularDynamics::MolecularDynamics(const PropertyMap &map)
-                  : ConcreteProperty<MolecularDynamics,Dynamics>(map),
-                    intgrator( Integrator::null() ),
-                    wspace( IntegratorWorkspace::null() ),
-                    timestep(1*femtosecond),
-                    num_moves(0), total_time(0)
+    : ConcreteProperty<MolecularDynamics, Dynamics>(map),
+      intgrator(Integrator::null()),
+      wspace(IntegratorWorkspace::null()),
+      timestep(1 * femtosecond),
+      num_moves(0), total_time(0)
 {
-    Dynamics::setEnsemble( Ensemble::NVE() );
+    Dynamics::setEnsemble(Ensemble::NVE());
 }
 
 /** Construct to perform moves on the molecules in the group 'molgroup'. This
     defaults to an all-atom velocity-verlet integrator */
 MolecularDynamics::MolecularDynamics(const MoleculeGroup &moleculegroup,
                                      const PropertyMap &map)
-                  : ConcreteProperty<MolecularDynamics,Dynamics>(map),
-                    intgrator( VelocityVerlet() ), timestep(1*femtosecond),
-                    num_moves(0), total_time(0)
+    : ConcreteProperty<MolecularDynamics, Dynamics>(map),
+      intgrator(VelocityVerlet()), timestep(1 * femtosecond),
+      num_moves(0), total_time(0)
 {
     wspace = intgrator.read().createWorkspace(moleculegroup, map);
-    Dynamics::setEnsemble( intgrator.read().ensemble() );
+    Dynamics::setEnsemble(intgrator.read().ensemble());
 }
 
 /** Construct a move for the passed molecule group, integrated
@@ -115,24 +112,24 @@ MolecularDynamics::MolecularDynamics(const MoleculeGroup &moleculegroup,
 MolecularDynamics::MolecularDynamics(const MoleculeGroup &moleculegroup,
                                      const Integrator &integrator,
                                      const PropertyMap &map)
-                  : ConcreteProperty<MolecularDynamics,Dynamics>(map),
-                    intgrator(integrator), timestep(1*femtosecond), num_moves(0),
-                    total_time(0)
+    : ConcreteProperty<MolecularDynamics, Dynamics>(map),
+      intgrator(integrator), timestep(1 * femtosecond), num_moves(0),
+      total_time(0)
 {
     wspace = intgrator.read().createWorkspace(moleculegroup, map);
-    Dynamics::setEnsemble( intgrator.read().ensemble() );
+    Dynamics::setEnsemble(intgrator.read().ensemble());
 }
 
 /** Construct a move for the passed molecule group, integrated with
     the passed timestep */
 MolecularDynamics::MolecularDynamics(const MoleculeGroup &molgroup,
                                      Time t, const PropertyMap &map)
-                  : ConcreteProperty<MolecularDynamics,Dynamics>(map),
-                    intgrator( VelocityVerlet() ), timestep(t), num_moves(0),
-                    total_time(0)
+    : ConcreteProperty<MolecularDynamics, Dynamics>(map),
+      intgrator(VelocityVerlet()), timestep(t), num_moves(0),
+      total_time(0)
 {
     wspace = intgrator.read().createWorkspace(molgroup, map);
-    Dynamics::setEnsemble( intgrator.read().ensemble() );
+    Dynamics::setEnsemble(intgrator.read().ensemble());
 }
 
 /** Construct a move for the passed molecule group, integrated
@@ -140,28 +137,30 @@ MolecularDynamics::MolecularDynamics(const MoleculeGroup &molgroup,
 MolecularDynamics::MolecularDynamics(const MoleculeGroup &molgroup,
                                      const Integrator &integrator,
                                      Time t, const PropertyMap &map)
-                  : ConcreteProperty<MolecularDynamics,Dynamics>(map),
-                    intgrator(integrator), timestep(t), num_moves(0),
-                    total_time(0)
+    : ConcreteProperty<MolecularDynamics, Dynamics>(map),
+      intgrator(integrator), timestep(t), num_moves(0),
+      total_time(0)
 {
     wspace = intgrator.read().createWorkspace(molgroup, map);
-    Dynamics::setEnsemble( intgrator.read().ensemble() );
+    Dynamics::setEnsemble(intgrator.read().ensemble());
 }
 
 /** Copy constructor */
 MolecularDynamics::MolecularDynamics(const MolecularDynamics &other)
-                  : ConcreteProperty<MolecularDynamics,Dynamics>(other),
-                    intgrator(other.intgrator), wspace(other.wspace),
-                    timestep(other.timestep), num_moves(other.num_moves),
-                    total_time(other.total_time)
-{}
+    : ConcreteProperty<MolecularDynamics, Dynamics>(other),
+      intgrator(other.intgrator), wspace(other.wspace),
+      timestep(other.timestep), num_moves(other.num_moves),
+      total_time(other.total_time)
+{
+}
 
 /** Destructor */
 MolecularDynamics::~MolecularDynamics()
-{}
+{
+}
 
 /** Copy assignment operator */
-MolecularDynamics& MolecularDynamics::operator=(const MolecularDynamics &other)
+MolecularDynamics &MolecularDynamics::operator=(const MolecularDynamics &other)
 {
     if (this != &other)
     {
@@ -198,9 +197,9 @@ bool MolecularDynamics::operator!=(const MolecularDynamics &other) const
 QString MolecularDynamics::toString() const
 {
     return QObject::tr("MolecularDynamics( %1, timeStep() == %2 fs, nMoves() == %3 )")
-                .arg(intgrator->toString())
-                .arg(timestep.to(femtosecond))
-                .arg(num_moves);
+        .arg(intgrator->toString())
+        .arg(timestep.to(femtosecond))
+        .arg(num_moves);
 }
 
 /** Return the number of moves completed using this object */
@@ -216,14 +215,14 @@ SireUnits::Dimension::Time MolecularDynamics::totalTime() const
 }
 
 /** Return the molecule group on which this move operates */
-const MoleculeGroup& MolecularDynamics::moleculeGroup() const
+const MoleculeGroup &MolecularDynamics::moleculeGroup() const
 {
     return wspace.read().moleculeGroup();
 }
 
 /** Return the integrator used to advance the coordinates
     from one timestep to the next */
-const Integrator& MolecularDynamics::integrator() const
+const Integrator &MolecularDynamics::integrator() const
 {
     return intgrator.read();
 }
@@ -258,8 +257,8 @@ void MolecularDynamics::setIntegrator(const Integrator &integrator)
     if (intgrator != integrator)
     {
         intgrator = integrator;
-        wspace = intgrator.read().createWorkspace( moleculeGroup(), propertyMap() );
-        Dynamics::setEnsemble( intgrator.read().ensemble() );
+        wspace = intgrator.read().createWorkspace(moleculeGroup(), propertyMap());
+        Dynamics::setEnsemble(intgrator.read().ensemble());
     }
 }
 
@@ -364,24 +363,23 @@ MolarEnergy MolecularDynamics::kineticEnergy() const
 /** Return the temperature of the system at the last move */
 Temperature MolecularDynamics::temperature() const
 {
-  SireUnits::Dimension::MolarEnergy ekin = MolecularDynamics::kineticEnergy();
-
-  // NOTE THAT THIS ONLY WORKS FOR 3D SPACE WHEN THERE IS ONE ATOM PER MOLECULE
-  // AND NO CONSTRAINTS...IN OTHER WORDS..NEED TO FIX THIS
-  //int ndofs = 3 * wspace.read().nMolecules();
-  int ndofs = 3 * 256;
+    SireUnits::Dimension::MolarEnergy ekin = MolecularDynamics::kineticEnergy();
 
-  SireUnits::Dimension::Temperature temp = ( ( 2 * ekin.value() ) / ( ndofs * k_boltz ) ) * kelvin ;
+    // NOTE THAT THIS ONLY WORKS FOR 3D SPACE WHEN THERE IS ONE ATOM PER MOLECULE
+    // AND NO CONSTRAINTS...IN OTHER WORDS..NEED TO FIX THIS
+    // int ndofs = 3 * wspace.read().nMolecules();
+    int ndofs = 3 * 256;
 
-  return temp;
+    SireUnits::Dimension::Temperature temp = ((2 * ekin.value()) / (ndofs * k_boltz.value())) * kelvin;
 
+    return temp;
 }
 
 /** Completely clear any move statistics - this clears all existing
     velocities */
 void MolecularDynamics::clearStatistics()
 {
-    wspace = intgrator.read().createWorkspace( moleculeGroup(), propertyMap() );
+    wspace = intgrator.read().createWorkspace(moleculeGroup(), propertyMap());
     num_moves = 0;
     total_time = Time(0);
 }
@@ -410,9 +408,9 @@ void MolecularDynamics::move(System &system, int nmoves, bool record_stats)
     if (nmoves <= 0)
         return;
 
-    //first, calculate the energy of the system - this is to prevent a
-    //weird bug that causes systems to blow up if the energy has not been
-    //calculated - THIS NEEDS FIXING!
+    // first, calculate the energy of the system - this is to prevent a
+    // weird bug that causes systems to blow up if the energy has not been
+    // calculated - THIS NEEDS FIXING!
     system.energy();
 
     MolecularDynamics old_state(*this);
@@ -429,9 +427,9 @@ void MolecularDynamics::move(System &system, int nmoves, bool record_stats)
         system = wspace.read().system();
 
         num_moves += nmoves;
-        total_time += nmoves*timestep;
+        total_time += nmoves * timestep;
     }
-    catch(...)
+    catch (...)
     {
         system = old_system_state;
         this->operator=(old_state);
@@ -440,12 +438,12 @@ void MolecularDynamics::move(System &system, int nmoves, bool record_stats)
     }
 }
 
-const char* MolecularDynamics::typeName()
+const char *MolecularDynamics::typeName()
 {
-    return QMetaType::typeName( qMetaTypeId<MolecularDynamics>() );
+    return QMetaType::typeName(qMetaTypeId<MolecularDynamics>());
 }
 
-MolecularDynamics* MolecularDynamics::clone() const
+MolecularDynamics *MolecularDynamics::clone() const
 {
     return new MolecularDynamics(*this);
 }
diff --git a/corelib/src/libs/SireMove/repexmove.cpp b/corelib/src/libs/SireMove/repexmove.cpp
index b3d3f20aa..dd6e1c83c 100644
--- a/corelib/src/libs/SireMove/repexmove.cpp
+++ b/corelib/src/libs/SireMove/repexmove.cpp
@@ -66,7 +66,7 @@ static const RegisterMetaType<RepExSubMove> r_repexsubmove;
 
 /** Serialise to a binary datastream */
 QDataStream &operator<<(QDataStream &ds,
-                                        const RepExSubMove &repexsubmove)
+                        const RepExSubMove &repexsubmove)
 {
     writeHeader(ds, r_repexsubmove, 2);
 
@@ -85,7 +85,7 @@ QDataStream &operator<<(QDataStream &ds,
 
     sds << repexsubmove.need_volume;
 
-    sds << static_cast<const SupraSubMove&>(repexsubmove);
+    sds << static_cast<const SupraSubMove &>(repexsubmove);
 
     return ds;
 }
@@ -101,15 +101,13 @@ QDataStream &operator>>(QDataStream &ds, RepExSubMove &repexsubmove)
 
         SharedDataStream sds(ds);
 
-        sds >> new_submove.partner_properties
-            >> new_submove.have_new_vals;
+        sds >> new_submove.partner_properties >> new_submove.have_new_vals;
 
         if (new_submove.have_new_vals)
         {
             double new_volume_i, new_energy_i, new_volume_j, new_energy_j;
 
-            sds >> new_volume_i >> new_energy_i
-                >> new_volume_j >> new_energy_j;
+            sds >> new_volume_i >> new_energy_i >> new_volume_j >> new_energy_j;
 
             new_submove.new_volume_i = new_volume_i * angstrom3;
             new_submove.new_energy_i = new_energy_i * kcal_per_mol;
@@ -123,26 +121,27 @@ QDataStream &operator>>(QDataStream &ds, RepExSubMove &repexsubmove)
         else
             new_submove.need_volume = true;
 
-        sds >> static_cast<SupraSubMove&>(new_submove);
+        sds >> static_cast<SupraSubMove &>(new_submove);
 
-        //check that all of the partner properties are valid...
-        for (QList< QPair<quint32,QVariant> >::const_iterator
-                                it = new_submove.partner_properties.constBegin();
+        // check that all of the partner properties are valid...
+        for (QList<QPair<quint32, QVariant>>::const_iterator
+                 it = new_submove.partner_properties.constBegin();
              it != new_submove.partner_properties.constEnd();
              ++it)
         {
             switch (it->first)
             {
-                case RepExSubMove::LAMBDA_VALUE:
-                case RepExSubMove::NRG_COMPONENT:
-                case RepExSubMove::SPACE_PROPERTY:
-                    break;
-
-                default:
-                    throw version_error( QObject::tr(
-                        "Version 1 of SireMove::RepExSubMove does not support "
-                        "the partner property with ID %2.")
-                            .arg(it->first), CODELOC );
+            case RepExSubMove::LAMBDA_VALUE:
+            case RepExSubMove::NRG_COMPONENT:
+            case RepExSubMove::SPACE_PROPERTY:
+                break;
+
+            default:
+                throw version_error(QObject::tr(
+                                        "Version 1 of SireMove::RepExSubMove does not support "
+                                        "the partner property with ID %2.")
+                                        .arg(it->first),
+                                    CODELOC);
             }
         }
 
@@ -156,67 +155,70 @@ QDataStream &operator>>(QDataStream &ds, RepExSubMove &repexsubmove)
 
 /** Constructor */
 RepExSubMove::RepExSubMove()
-             : ConcreteProperty<RepExSubMove,SupraSubMove>(),
-               new_volume_i(0), new_energy_i(0),
-               new_volume_j(0), new_energy_j(0),
-               have_new_vals(false), need_volume(false)
-{}
+    : ConcreteProperty<RepExSubMove, SupraSubMove>(),
+      new_volume_i(0), new_energy_i(0),
+      new_volume_j(0), new_energy_j(0),
+      have_new_vals(false), need_volume(false)
+{
+}
 
 /** Internal function used to add a property of our partner replica
     that differs from the value in this replica */
-template<class T>
+template <class T>
 void RepExSubMove::addPartnerProperty(quint32 property, const T &value)
 {
-    partner_properties.append( QPair<quint32,QVariant>(property,
-                                                       QVariant::fromValue<T>(value)) );
+    partner_properties.append(QPair<quint32, QVariant>(property,
+                                                       QVariant::fromValue<T>(value)));
 }
 
 /** Construct the sub-move that will perform a move on 'replica_a', after
     which it will then calculate the values necessary to test the
     swap from 'replica_a' to 'replica_b' */
 RepExSubMove::RepExSubMove(const Replica &replica_a, const Replica &replica_b)
-             : ConcreteProperty<RepExSubMove,SupraSubMove>(),
-               new_volume_i(0), new_energy_i(0),
-               new_volume_j(0), new_energy_j(0),
-               have_new_vals(false)
+    : ConcreteProperty<RepExSubMove, SupraSubMove>(),
+      new_volume_i(0), new_energy_i(0),
+      new_volume_j(0), new_energy_j(0),
+      have_new_vals(false)
 {
     need_volume = replica_a.ensemble().isConstantPressure() and
                   replica_b.ensemble().isConstantPressure();
 
     if (replica_b.lambdaValue() != replica_a.lambdaValue())
     {
-        addPartnerProperty( LAMBDA_VALUE, replica_b.lambdaValue() );
+        addPartnerProperty(LAMBDA_VALUE, replica_b.lambdaValue());
     }
 
     if (replica_b.energyComponent() != replica_a.energyComponent())
     {
-        addPartnerProperty( NRG_COMPONENT, replica_b.energyComponent() );
+        addPartnerProperty(NRG_COMPONENT, replica_b.energyComponent());
     }
 
     if (need_volume)
     {
         if (replica_b.spaceProperty() != replica_a.spaceProperty())
         {
-            addPartnerProperty( SPACE_PROPERTY, replica_b.spaceProperty() );
+            addPartnerProperty(SPACE_PROPERTY, replica_b.spaceProperty());
         }
     }
 }
 
 /** Copy constructor */
 RepExSubMove::RepExSubMove(const RepExSubMove &other)
-             : ConcreteProperty<RepExSubMove,SupraSubMove>(other),
-               new_volume_i(other.new_volume_i), new_energy_i(other.new_energy_i),
-               new_volume_j(other.new_volume_j), new_energy_j(other.new_energy_j),
-               partner_properties(other.partner_properties),
-               have_new_vals(other.have_new_vals), need_volume(other.need_volume)
-{}
+    : ConcreteProperty<RepExSubMove, SupraSubMove>(other),
+      new_volume_i(other.new_volume_i), new_energy_i(other.new_energy_i),
+      new_volume_j(other.new_volume_j), new_energy_j(other.new_energy_j),
+      partner_properties(other.partner_properties),
+      have_new_vals(other.have_new_vals), need_volume(other.need_volume)
+{
+}
 
 /** Destructor */
 RepExSubMove::~RepExSubMove()
-{}
+{
+}
 
 /** Copy assignment operator */
-RepExSubMove& RepExSubMove::operator=(const RepExSubMove &other)
+RepExSubMove &RepExSubMove::operator=(const RepExSubMove &other)
 {
     if (this != &other)
     {
@@ -241,13 +243,13 @@ RepExSubMove& RepExSubMove::operator=(const RepExSubMove &other)
 bool RepExSubMove::operator==(const RepExSubMove &other) const
 {
     return (this == &other) or
-           ( have_new_vals == other.have_new_vals and
-             need_volume == other.need_volume and
-             new_volume_i == other.new_volume_i and
-             new_energy_i == other.new_energy_i and
-             new_volume_j == other.new_volume_j and
-             new_energy_j == other.new_energy_j and
-             SupraSubMove::operator==(other) );
+           (have_new_vals == other.have_new_vals and
+            need_volume == other.need_volume and
+            new_volume_i == other.new_volume_i and
+            new_energy_i == other.new_energy_i and
+            new_volume_j == other.new_volume_j and
+            new_energy_j == other.new_energy_j and
+            SupraSubMove::operator==(other));
 }
 
 /** Comparison operator */
@@ -263,37 +265,39 @@ QString RepExSubMove::toString() const
     {
         if (need_volume)
         {
-            return QObject::tr( "RepExSubMove( E_i = %1 kcal mol-1, V_i = %2 A^3 : "
-                                "E_j = %3 kcal mol-1, V_j = %4 A^3 )")
-                        .arg( new_energy_i.to(kcal_per_mol) )
-                        .arg( new_volume_i.to(angstrom3) )
-                        .arg( new_energy_j.to(kcal_per_mol) )
-                        .arg( new_volume_j.to(angstrom3) );
+            return QObject::tr("RepExSubMove( E_i = %1 kcal mol-1, V_i = %2 A^3 : "
+                               "E_j = %3 kcal mol-1, V_j = %4 A^3 )")
+                .arg(new_energy_i.to(kcal_per_mol))
+                .arg(new_volume_i.to(angstrom3))
+                .arg(new_energy_j.to(kcal_per_mol))
+                .arg(new_volume_j.to(angstrom3));
         }
         else
         {
-            return QObject::tr( "RepExSubMove( E_i = %1 kcal mol-1 : "
-                                "E_j = %2 kcal mol-1 )")
-                        .arg( new_energy_i.to(kcal_per_mol) )
-                        .arg( new_energy_j.to(kcal_per_mol) );
+            return QObject::tr("RepExSubMove( E_i = %1 kcal mol-1 : "
+                               "E_j = %2 kcal mol-1 )")
+                .arg(new_energy_i.to(kcal_per_mol))
+                .arg(new_energy_j.to(kcal_per_mol));
         }
     }
     else
-        return QObject::tr( "RepExSubMove()" );
+        return QObject::tr("RepExSubMove()");
 }
 
 static void throwNoValues(const char *value, const QString &codeloc)
 {
-    throw SireError::invalid_state( QObject::tr(
-        "Cannot get the value of %1 as new values have not been evaluated!")
-            .arg(value), codeloc );
+    throw SireError::invalid_state(QObject::tr(
+                                       "Cannot get the value of %1 as new values have not been evaluated!")
+                                       .arg(value),
+                                   codeloc);
 }
 
 static void throwNoVolume(const char *value, const QString &codeloc)
 {
-    throw SireError::invalid_state( QObject::tr(
-        "Cannot get the volume %1 as the move indicated that volumes weren't necessary!")
-            .arg(value), codeloc );
+    throw SireError::invalid_state(QObject::tr(
+                                       "Cannot get the volume %1 as the move indicated that volumes weren't necessary!")
+                                       .arg(value),
+                                   codeloc);
 }
 
 /** Return the energy of the replica in its normal state at the
@@ -301,7 +305,7 @@ static void throwNoVolume(const char *value, const QString &codeloc)
 MolarEnergy RepExSubMove::energy_i() const
 {
     if (not have_new_vals)
-        ::throwNoValues( "E_i", CODELOC );
+        ::throwNoValues("E_i", CODELOC);
 
     return new_energy_i;
 }
@@ -311,10 +315,10 @@ MolarEnergy RepExSubMove::energy_i() const
 Volume RepExSubMove::volume_i() const
 {
     if (not have_new_vals)
-        ::throwNoValues( "V_i", CODELOC );
+        ::throwNoValues("V_i", CODELOC);
 
     if (not need_volume)
-        ::throwNoVolume( "V_i", CODELOC );
+        ::throwNoVolume("V_i", CODELOC);
 
     return new_volume_i;
 }
@@ -324,7 +328,7 @@ Volume RepExSubMove::volume_i() const
 MolarEnergy RepExSubMove::energy_j() const
 {
     if (not have_new_vals)
-        ::throwNoValues( "E_j", CODELOC );
+        ::throwNoValues("E_j", CODELOC);
 
     return new_energy_j;
 }
@@ -334,10 +338,10 @@ MolarEnergy RepExSubMove::energy_j() const
 Volume RepExSubMove::volume_j() const
 {
     if (not have_new_vals)
-        ::throwNoValues( "V_j", CODELOC );
+        ::throwNoValues("V_j", CODELOC);
 
     if (not need_volume)
-        ::throwNoVolume( "V_j", CODELOC );
+        ::throwNoVolume("V_j", CODELOC);
 
     return new_volume_j;
 }
@@ -347,15 +351,16 @@ Volume RepExSubMove::volume_j() const
 
     \throw SireError::invalid_cast
 */
-template<class T>
+template <class T>
 static T convert(const QVariant &value)
 {
     if (not value.canConvert<T>())
-        throw SireError::invalid_cast( QObject::tr(
-            "Cannot apply a deferred command as the argument of type %1 "
-            "cannot be cast to a value of type %2.")
-                .arg( typeid(T).name() )
-                .arg( QVariant::typeToName(value.type()) ), CODELOC );
+        throw SireError::invalid_cast(QObject::tr(
+                                          "Cannot apply a deferred command as the argument of type %1 "
+                                          "cannot be cast to a value of type %2.")
+                                          .arg(typeid(T).name())
+                                          .arg(QVariant::typeToName(value.type())),
+                                      CODELOC);
 
     return value.value<T>();
 }
@@ -372,7 +377,7 @@ void RepExSubMove::evaluateSwappedState(const Replica &replica)
     if (state_i.isPacked())
         state_i.unpack();
 
-    //get the energy and volume at this state
+    // get the energy and volume at this state
     new_energy_i = state_i.energy();
 
     if (need_volume)
@@ -390,41 +395,43 @@ void RepExSubMove::evaluateSwappedState(const Replica &replica)
         Symbol nrg_component = state_i.energyComponent();
         PropertyName space_property = state_i.spaceProperty();
 
-        for (QList< QPair<quint32,QVariant> >::const_iterator
-                                                it = partner_properties.constBegin();
+        for (QList<QPair<quint32, QVariant>>::const_iterator
+                 it = partner_properties.constBegin();
              it != partner_properties.constEnd();
              ++it)
         {
             switch (it->first)
             {
-                case LAMBDA_VALUE:
-                {
-                    if (state_i.lambdaComponent().isNull())
-                        throw SireError::incompatible_error( QObject::tr(
-                            "Cannot set the lambda value for a replica that doesn't "
-                            "have a lambda component!"), CODELOC );
-
-                    //set a new lambda value
-                    state_j.setComponent( state_i.lambdaComponent(),
-                                          ::convert<double>(it->second) );
-                    break;
-                }
-                case NRG_COMPONENT:
-                    //set a new Hamiltonian (represented by the component)
-                    nrg_component = ::convert<Symbol>(it->second);
-                    break;
-
-                case SPACE_PROPERTY:
-                    //set a new space property
-                    space_property = ::convert<PropertyName>(it->second);
-                    break;
-
-                default:
-                    throw SireError::unsupported( QObject::tr(
-                        "A request was made of an unsuppoted action in RepExSubMove. "
-                        "The action with ID %1 was requested, but this is not "
-                        "supported with this version of RepExSubMove.")
-                            .arg(it->first), CODELOC );
+            case LAMBDA_VALUE:
+            {
+                if (state_i.lambdaComponent().isNull())
+                    throw SireError::incompatible_error(QObject::tr(
+                                                            "Cannot set the lambda value for a replica that doesn't "
+                                                            "have a lambda component!"),
+                                                        CODELOC);
+
+                // set a new lambda value
+                state_j.setComponent(state_i.lambdaComponent(),
+                                     ::convert<double>(it->second));
+                break;
+            }
+            case NRG_COMPONENT:
+                // set a new Hamiltonian (represented by the component)
+                nrg_component = ::convert<Symbol>(it->second);
+                break;
+
+            case SPACE_PROPERTY:
+                // set a new space property
+                space_property = ::convert<PropertyName>(it->second);
+                break;
+
+            default:
+                throw SireError::unsupported(QObject::tr(
+                                                 "A request was made of an unsuppoted action in RepExSubMove. "
+                                                 "The action with ID %1 was requested, but this is not "
+                                                 "supported with this version of RepExSubMove.")
+                                                 .arg(it->first),
+                                             CODELOC);
             }
         }
 
@@ -441,7 +448,7 @@ void RepExSubMove::evaluateSwappedState(const Replica &replica)
 void RepExSubMove::move(SupraSubSystem &system, int n_supra_moves,
                         int n_supra_moves_per_block, bool record_stats)
 {
-    //replica exchange moves work only with Replica objects
+    // replica exchange moves work only with Replica objects
     Replica &replica = system.asA<Replica>();
 
     SupraSubSystemPtr old_replica = replica.clone();
@@ -459,26 +466,26 @@ void RepExSubMove::move(SupraSubSystem &system, int n_supra_moves,
             return;
         }
 
-        //unpack the system, if necessary
+        // unpack the system, if necessary
         bool replica_was_packed = replica.isPacked();
         replica.unpack();
 
-        //perform the moves
-        for (int i=0; i<n_supra_moves; ++i)
+        // perform the moves
+        for (int i = 0; i < n_supra_moves; ++i)
         {
             replica.subMove(record_stats);
         }
 
-        //if we have finished a block of sub-moves, then collect
-        //the information necessary to perform the replica exchange test
+        // if we have finished a block of sub-moves, then collect
+        // the information necessary to perform the replica exchange test
         if (n_supra_moves >= n_supra_moves_per_block)
             this->evaluateSwappedState(replica);
 
-        //repack the system, if necessary
+        // repack the system, if necessary
         if (replica_was_packed)
             replica.pack();
     }
-    catch(...)
+    catch (...)
     {
         replica.copy(*old_replica);
         this->copy(*old_state);
@@ -487,9 +494,9 @@ void RepExSubMove::move(SupraSubSystem &system, int n_supra_moves,
     }
 }
 
-const char* RepExSubMove::typeName()
+const char *RepExSubMove::typeName()
 {
-    return QMetaType::typeName( qMetaTypeId<RepExSubMove>() );
+    return QMetaType::typeName(qMetaTypeId<RepExSubMove>());
 }
 
 ////////////
@@ -510,7 +517,7 @@ QDataStream &operator<<(QDataStream &ds, const RepExMove &repexmove)
         << repexmove.nreject
         << repexmove.swap_monitors
         << repexmove.disable_swaps
-        << static_cast<const SupraMove&>(repexmove);
+        << static_cast<const SupraMove &>(repexmove);
 
     return ds;
 }
@@ -526,22 +533,13 @@ QDataStream &operator>>(QDataStream &ds, RepExMove &repexmove)
     {
         SharedDataStream sds(ds);
 
-        sds >> repexmove.rangenerator
-            >> repexmove.naccept
-            >> repexmove.nreject
-            >> repexmove.swap_monitors
-            >> repexmove.disable_swaps
-            >> static_cast<SupraMove&>(repexmove);
+        sds >> repexmove.rangenerator >> repexmove.naccept >> repexmove.nreject >> repexmove.swap_monitors >> repexmove.disable_swaps >> static_cast<SupraMove &>(repexmove);
     }
     else if (v == 2)
     {
         SharedDataStream sds(ds);
 
-        sds >> repexmove.rangenerator
-            >> repexmove.naccept
-            >> repexmove.nreject
-            >> repexmove.swap_monitors
-            >> static_cast<SupraMove&>(repexmove);
+        sds >> repexmove.rangenerator >> repexmove.naccept >> repexmove.nreject >> repexmove.swap_monitors >> static_cast<SupraMove &>(repexmove);
     }
     else if (v == 1)
     {
@@ -549,10 +547,7 @@ QDataStream &operator>>(QDataStream &ds, RepExMove &repexmove)
 
         quint32 nmoves;
 
-        sds >> repexmove.rangenerator
-            >> nmoves
-            >> repexmove.naccept
-            >> repexmove.nreject;
+        sds >> repexmove.rangenerator >> nmoves >> repexmove.naccept >> repexmove.nreject;
 
         repexmove.swap_monitors = false;
     }
@@ -564,24 +559,27 @@ QDataStream &operator>>(QDataStream &ds, RepExMove &repexmove)
 
 /** Constructor */
 RepExMove::RepExMove()
-          : ConcreteProperty<RepExMove,SupraMove>(),
-            naccept(0), nreject(0), swap_monitors(false), disable_swaps(false)
-{}
+    : ConcreteProperty<RepExMove, SupraMove>(),
+      naccept(0), nreject(0), swap_monitors(false), disable_swaps(false)
+{
+}
 
 /** Copy constructor */
 RepExMove::RepExMove(const RepExMove &other)
-          : ConcreteProperty<RepExMove,SupraMove>(other),
-            naccept(other.naccept), nreject(other.nreject),
-            swap_monitors(other.swap_monitors),
-            disable_swaps(other.disable_swaps)
-{}
+    : ConcreteProperty<RepExMove, SupraMove>(other),
+      naccept(other.naccept), nreject(other.nreject),
+      swap_monitors(other.swap_monitors),
+      disable_swaps(other.disable_swaps)
+{
+}
 
 /** Destructor */
 RepExMove::~RepExMove()
-{}
+{
+}
 
 /** Copy assignment operator */
-RepExMove& RepExMove::operator=(const RepExMove &other)
+RepExMove &RepExMove::operator=(const RepExMove &other)
 {
     if (this != &other)
     {
@@ -657,9 +655,9 @@ double RepExMove::acceptanceRatio() const
 QString RepExMove::toString() const
 {
     return QObject::tr("RepExMove( %1 accepted, %2 rejected : %3 %% )")
-                .arg(this->nAccepted())
-                .arg(this->nRejected())
-                .arg(100 * this->acceptanceRatio());
+        .arg(this->nAccepted())
+        .arg(this->nRejected())
+        .arg(100 * this->acceptanceRatio());
 }
 
 /** Clear the move statistics */
@@ -677,7 +675,7 @@ void RepExMove::setGenerator(const RanGenerator &generator)
 }
 
 /** Return the random number generator used for the replica exchange tests */
-const RanGenerator& RepExMove::generator() const
+const RanGenerator &RepExMove::generator() const
 {
     return rangenerator;
 }
@@ -694,34 +692,34 @@ static SupraSubSim submitSimulation(Nodes &nodes, const Replica &replica,
 {
     Node node = nodes.getNode();
 
-    return SupraSubSim::run( node, replica, RepExSubMove(), 1, record_stats );
+    return SupraSubSim::run(node, replica, RepExSubMove(), 1, record_stats);
 }
 
 /** Internal function used to submit the two simulations for the replicas
     'replica_a' and 'replica_b', telling each simulation to follow the
     simulation by evaluating the values necessary to perform a swap test
     between these two replicas */
-static QPair<SupraSubSim,SupraSubSim> submitSimulation(
-                                    Nodes &nodes, const Replica &replica_a,
-                                    const Replica &replica_b, bool record_stats)
+static QPair<SupraSubSim, SupraSubSim> submitSimulation(
+    Nodes &nodes, const Replica &replica_a,
+    const Replica &replica_b, bool record_stats)
 {
-    QPair<SupraSubSim,SupraSubSim> sims;
+    QPair<SupraSubSim, SupraSubSim> sims;
 
-    //submit each simulation in a separate scope so that
-    //the node is released once the simulation has finished
+    // submit each simulation in a separate scope so that
+    // the node is released once the simulation has finished
     {
         Node node_a = nodes.getNode();
 
-        sims.first = SupraSubSim::run( node_a, replica_a,
-                                       RepExSubMove(replica_a, replica_b),
-                                       1, record_stats );
+        sims.first = SupraSubSim::run(node_a, replica_a,
+                                      RepExSubMove(replica_a, replica_b),
+                                      1, record_stats);
     }
 
     Node node_b = nodes.getNode();
 
-    sims.second = SupraSubSim::run( node_b, replica_b,
-                                    RepExSubMove(replica_b, replica_a),
-                                                 1, record_stats );
+    sims.second = SupraSubSim::run(node_b, replica_b,
+                                   RepExSubMove(replica_b, replica_a),
+                                   1, record_stats);
 
     return sims;
 }
@@ -738,8 +736,8 @@ static QVector<SupraSubSim> submitSimulations(Nodes &nodes, Replicas &replicas,
 
     QVector<SupraSubSim> subsims(nreplicas);
 
-    //pair the replicas up...
-    //do we swap the even pairs or the odd pairs?
+    // pair the replicas up...
+    // do we swap the even pairs or the odd pairs?
     int start = 1;
 
     if (even_pairs)
@@ -747,26 +745,26 @@ static QVector<SupraSubSim> submitSimulations(Nodes &nodes, Replicas &replicas,
 
     if (start == 1)
     {
-        //the first replica hasn't got a partner - start it on its own
+        // the first replica hasn't got a partner - start it on its own
         subsims[0] = ::submitSimulation(nodes, replicas[0], record_stats);
     }
 
-    if ( (nreplicas-start) % 2 == 1 )
+    if ((nreplicas - start) % 2 == 1)
     {
-        //the last replica hasn't got a partner - start it on its own too
-        subsims[nreplicas-1] = ::submitSimulation(nodes, replicas[nreplicas-1],
-                                                  record_stats );
+        // the last replica hasn't got a partner - start it on its own too
+        subsims[nreplicas - 1] = ::submitSimulation(nodes, replicas[nreplicas - 1],
+                                                    record_stats);
     }
 
-    for (int i=start; i<nreplicas-1; i+=2)
+    for (int i = start; i < nreplicas - 1; i += 2)
     {
-        //submit the simulations for replica i and replica i+1
-        QPair<SupraSubSim,SupraSubSim> sims = ::submitSimulation( nodes, replicas[i],
-                                                                  replicas[i+1],
-                                                                  record_stats );
+        // submit the simulations for replica i and replica i+1
+        QPair<SupraSubSim, SupraSubSim> sims = ::submitSimulation(nodes, replicas[i],
+                                                                  replicas[i + 1],
+                                                                  record_stats);
 
         subsims[i] = sims.first;
-        subsims[i+1] = sims.second;
+        subsims[i + 1] = sims.second;
     }
 
     return subsims;
@@ -791,7 +789,7 @@ static void waitUntilFinished(Nodes &nodes, QVector<SupraSubSim> &subsims, int m
 
         all_finished = true;
 
-        for (int i=0; i<nreplicas; ++i)
+        for (int i = 0; i < nreplicas; ++i)
         {
             SupraSubSim &subsim = subsims[i];
 
@@ -799,7 +797,7 @@ static void waitUntilFinished(Nodes &nodes, QVector<SupraSubSim> &subsims, int m
 
             if (subsim.isError() or subsim.wasAborted())
             {
-                //resubmit this calculation
+                // resubmit this calculation
                 Node node = nodes.getNode();
                 subsim = SupraSubSim::run(node, subsim.input());
 
@@ -807,11 +805,11 @@ static void waitUntilFinished(Nodes &nodes, QVector<SupraSubSim> &subsims, int m
             }
             else if (not subsim.hasFinished())
             {
-                //continue the calculation from where it finished
+                // continue the calculation from where it finished
                 SupraSubSimPacket simpacket = subsim.result();
 
                 Node node = nodes.getNode();
-                subsim = SupraSubSim::run( node, simpacket );
+                subsim = SupraSubSim::run(node, simpacket);
 
                 all_finished = false;
             }
@@ -819,8 +817,8 @@ static void waitUntilFinished(Nodes &nodes, QVector<SupraSubSim> &subsims, int m
 
         if (not all_finished)
         {
-            //wait for the resubmitted calculations to finish
-            for (int i=0; i<nreplicas; ++i)
+            // wait for the resubmitted calculations to finish
+            for (int i = 0; i < nreplicas; ++i)
             {
                 subsims[i].wait();
             }
@@ -833,18 +831,18 @@ static void waitUntilFinished(Nodes &nodes, QVector<SupraSubSim> &subsims, int m
 bool RepExMove::testPair(const Replica &replica_a, const RepExSubMove &move_a,
                          const Replica &replica_b, const RepExSubMove &move_b) const
 {
-    //get the ensembles of the two replicas
+    // get the ensembles of the two replicas
     const Ensemble &ensemble_a = replica_a.ensemble();
     const Ensemble &ensemble_b = replica_b.ensemble();
 
-    if ( (ensemble_a.isNVT() and ensemble_a.isNVT()) or
-         (ensemble_b.isNPT() and ensemble_b.isNPT()) )
+    if ((ensemble_a.isNVT() and ensemble_a.isNVT()) or
+        (ensemble_b.isNPT() and ensemble_b.isNPT()))
     {
         bool need_pv = (ensemble_a.isNPT() and ensemble_b.isNPT());
 
-        //get the values of the thermodynamic parameters
-        double beta_a = 1.0 / (k_boltz * ensemble_a.temperature()).value();
-        double beta_b = 1.0 / (k_boltz * ensemble_b.temperature()).value();
+        // get the values of the thermodynamic parameters
+        double beta_a = 1.0 / (k_boltz.value() * ensemble_a.temperature()).value();
+        double beta_b = 1.0 / (k_boltz.value() * ensemble_b.temperature()).value();
 
         Pressure p_a(0);
         Pressure p_b(0);
@@ -855,8 +853,8 @@ bool RepExMove::testPair(const Replica &replica_a, const RepExSubMove &move_a,
             p_b = ensemble_b.pressure();
         }
 
-        //now get the values of the system properties at their current state,
-        //and at their swapped states
+        // now get the values of the system properties at their current state,
+        // and at their swapped states
         MolarEnergy H_a_i = move_a.energy_i();
         MolarEnergy H_a_j = move_a.energy_j();
 
@@ -878,28 +876,28 @@ bool RepExMove::testPair(const Replica &replica_a, const RepExSubMove &move_a,
             V_b_j = move_b.volume_j();
         }
 
-        //now calculate delta needed for the Monte Carlo test
+        // now calculate delta needed for the Monte Carlo test
         //
-        //  For derivation see Appendix C of Christopher Woods' thesis
-        //   (or original replica exchange literature of course!)
+        //   For derivation see Appendix C of Christopher Woods' thesis
+        //    (or original replica exchange literature of course!)
         //
-        //  delta = beta_b * [ H_b_i - H_b_j + P_b (V_b_i - V_b_j) ] +
-        //          beta_a * [ H_a_i - H_a_j + P_a (V_a_i - V_a_j) ]
+        //   delta = beta_b * [ H_b_i - H_b_j + P_b (V_b_i - V_b_j) ] +
+        //           beta_a * [ H_a_i - H_a_j + P_a (V_a_i - V_a_j) ]
 
-        double delta = beta_b * ( H_b_i - H_b_j + p_b*(V_b_i - V_b_j) ) +
-                       beta_a * ( H_a_i - H_a_j + p_a*(V_a_i - V_a_j) );
+        double delta = beta_b * (H_b_i - H_b_j + p_b * (V_b_i - V_b_j)) +
+                       beta_a * (H_a_i - H_a_j + p_a * (V_a_i - V_a_j));
 
-        bool move_passed = ( delta > 0 or (std::exp(delta) >= rangenerator.rand()) );
+        bool move_passed = (delta > 0 or (std::exp(delta) >= rangenerator.rand()));
 
         return move_passed;
     }
     else
     {
-        throw SireError::incompatible_error( QObject::tr(
-            "There is no available replica exchange test that allows tests between "
-            "replicas with ensembles %1 and %2.")
-                .arg(ensemble_a.toString(), ensemble_b.toString()), CODELOC );
-
+        throw SireError::incompatible_error(QObject::tr(
+                                                "There is no available replica exchange test that allows tests between "
+                                                "replicas with ensembles %1 and %2.")
+                                                .arg(ensemble_a.toString(), ensemble_b.toString()),
+                                            CODELOC);
     }
 
     return false;
@@ -918,16 +916,16 @@ void RepExMove::testAndSwap(Replicas &replicas, const QVector<RepExSubMove> &sub
         if (even_pairs)
             start = 0;
 
-        //loop over all pairs
-        for (int i=start; i<nreplicas-1; i+=2)
+        // loop over all pairs
+        for (int i = start; i < nreplicas - 1; i += 2)
         {
-            qDebug() << "Test replicas" << i << (i+1);
+            qDebug() << "Test replicas" << i << (i + 1);
 
             if (this->testPair(replicas[i], submoves.at(i),
-                               replicas[i+1], submoves.at(i+1) ))
+                               replicas[i + 1], submoves.at(i + 1)))
             {
-                //swap the replicas
-                replicas.swapSystems(i, i+1, swap_monitors);
+                // swap the replicas
+                replicas.swapSystems(i, i + 1, swap_monitors);
                 ++naccept;
             }
             else
@@ -942,43 +940,42 @@ void RepExMove::testAndSwap(Replicas &replicas, const QVector<RepExSubMove> &sub
     pairs */
 void RepExMove::performMove(Nodes &nodes, Replicas &replicas, bool record_stats)
 {
-    //will we swap even pairs or odd pairs?
+    // will we swap even pairs or odd pairs?
     bool even_pairs = true;
 
     if (replicas.nReplicas() > 2)
         even_pairs = rangenerator.randBool();
 
-    //submit all of the simulations
+    // submit all of the simulations
     QVector<SupraSubSim> subsims = ::submitSimulations(nodes, replicas,
                                                        even_pairs, record_stats);
 
-    //wait for all of the simulations to finish (retrying broken simulations
-    //just five times)
+    // wait for all of the simulations to finish (retrying broken simulations
+    // just five times)
     ::waitUntilFinished(nodes, subsims, 5);
 
-    //copy the results back into the replicas
+    // copy the results back into the replicas
     int nreplicas = replicas.count();
 
     QVector<RepExSubMove> submoves(nreplicas);
     submoves.squeeze();
 
-    for (int i=0; i<nreplicas; ++i)
+    for (int i = 0; i < nreplicas; ++i)
     {
-        submoves[i] = subsims[i].result().subMoves().asA<SameSupraSubMoves>()[0]
-                                         .asA<RepExSubMove>();
+        submoves[i] = subsims[i].result().subMoves().asA<SameSupraSubMoves>()[0].asA<RepExSubMove>();
 
-        replicas.setReplica( i, subsims[i].result().subSystem() );
+        replicas.setReplica(i, subsims[i].result().subSystem());
     }
 
-    //get rid of the simulation handles, as they are no longer needed
+    // get rid of the simulation handles, as they are no longer needed
     //(and we need to save memory if we can)
     subsims = QVector<SupraSubSim>();
 
-    //now perform all of the replica exchange tests
+    // now perform all of the replica exchange tests
     if (not disable_swaps)
         this->testAndSwap(replicas, submoves, even_pairs, record_stats);
 
-    //now collect any necessary statistics
+    // now collect any necessary statistics
     if (record_stats)
         replicas.collectSupraStats();
 }
@@ -1002,14 +999,14 @@ void RepExMove::move(SupraSystem &system, int nmoves, bool record_stats)
 
     try
     {
-        //try to get as many nodes as possible to run the moves
-        Nodes nodes = Cluster::getNodes( replicas.nReplicas() - 1, 5000 );
+        // try to get as many nodes as possible to run the moves
+        Nodes nodes = Cluster::getNodes(replicas.nReplicas() - 1, 5000);
 
-        ///hold this_thread in a local scope to ensure it is deleted before 'nodes'
+        /// hold this_thread in a local scope to ensure it is deleted before 'nodes'
         {
             ThisThread this_thread = nodes.borrowThisThread();
 
-            for (int i=0; i<nmoves; ++i)
+            for (int i = 0; i < nmoves; ++i)
             {
                 this->performMove(nodes, replicas, record_stats);
             }
@@ -1017,7 +1014,7 @@ void RepExMove::move(SupraSystem &system, int nmoves, bool record_stats)
             SupraMove::incrementNMoves(nmoves);
         }
     }
-    catch(...)
+    catch (...)
     {
         replicas.copy(*old_replicas);
         this->copy(*old_state);
@@ -1025,7 +1022,7 @@ void RepExMove::move(SupraSystem &system, int nmoves, bool record_stats)
     }
 }
 
-const char* RepExMove::typeName()
+const char *RepExMove::typeName()
 {
-    return QMetaType::typeName( qMetaTypeId<RepExMove>() );
+    return QMetaType::typeName(qMetaTypeId<RepExMove>());
 }
diff --git a/corelib/src/libs/SireMove/repexmove2.cpp b/corelib/src/libs/SireMove/repexmove2.cpp
index 683c19174..8e6b83aa9 100644
--- a/corelib/src/libs/SireMove/repexmove2.cpp
+++ b/corelib/src/libs/SireMove/repexmove2.cpp
@@ -42,7 +42,7 @@
 #include "SireError/errors.h"
 
 // tbb::task has been deprecated!
-//#include "tbb/task.h"
+// #include "tbb/task.h"
 
 #include <QVector>
 #include <QDebug>
@@ -73,7 +73,7 @@ QDataStream &operator<<(QDataStream &ds, const RepExMove2 &repexmove2)
         << repexmove2.nreject
         << repexmove2.swap_monitors
         << repexmove2.disable_swaps
-        << static_cast<const SupraMove&>(repexmove2);
+        << static_cast<const SupraMove &>(repexmove2);
 
     return ds;
 }
@@ -87,12 +87,7 @@ QDataStream &operator>>(QDataStream &ds, RepExMove2 &repexmove2)
     {
         SharedDataStream sds(ds);
 
-        sds >> repexmove2.rangenerator
-            >> repexmove2.naccept
-            >> repexmove2.nreject
-            >> repexmove2.swap_monitors
-            >> repexmove2.disable_swaps
-            >> static_cast<SupraMove&>(repexmove2);
+        sds >> repexmove2.rangenerator >> repexmove2.naccept >> repexmove2.nreject >> repexmove2.swap_monitors >> repexmove2.disable_swaps >> static_cast<SupraMove &>(repexmove2);
     }
     else
         throw version_error(v, "1", r_repexmove2, CODELOC);
@@ -102,24 +97,27 @@ QDataStream &operator>>(QDataStream &ds, RepExMove2 &repexmove2)
 
 /** Constructor */
 RepExMove2::RepExMove2()
-           : ConcreteProperty<RepExMove2,SupraMove>(),
-             naccept(0), nreject(0), swap_monitors(false), disable_swaps(false)
-{}
+    : ConcreteProperty<RepExMove2, SupraMove>(),
+      naccept(0), nreject(0), swap_monitors(false), disable_swaps(false)
+{
+}
 
 /** Copy constructor */
 RepExMove2::RepExMove2(const RepExMove2 &other)
-           : ConcreteProperty<RepExMove2,SupraMove>(other),
-             naccept(other.naccept), nreject(other.nreject),
-             swap_monitors(other.swap_monitors),
-             disable_swaps(other.disable_swaps)
-{}
+    : ConcreteProperty<RepExMove2, SupraMove>(other),
+      naccept(other.naccept), nreject(other.nreject),
+      swap_monitors(other.swap_monitors),
+      disable_swaps(other.disable_swaps)
+{
+}
 
 /** Destructor */
 RepExMove2::~RepExMove2()
-{}
+{
+}
 
 /** Copy assignment operator */
-RepExMove2& RepExMove2::operator=(const RepExMove2 &other)
+RepExMove2 &RepExMove2::operator=(const RepExMove2 &other)
 {
     if (this != &other)
     {
@@ -195,9 +193,9 @@ double RepExMove2::acceptanceRatio() const
 QString RepExMove2::toString() const
 {
     return QObject::tr("RepExMove2( %1 accepted, %2 rejected : %3 %% )")
-                .arg(this->nAccepted())
-                .arg(this->nRejected())
-                .arg(100 * this->acceptanceRatio());
+        .arg(this->nAccepted())
+        .arg(this->nRejected())
+        .arg(100 * this->acceptanceRatio());
 }
 
 /** Clear the move statistics */
@@ -215,7 +213,7 @@ void RepExMove2::setGenerator(const RanGenerator &generator)
 }
 
 /** Return the random number generator used for the replica exchange tests */
-const RanGenerator& RepExMove2::generator() const
+const RanGenerator &RepExMove2::generator() const
 {
     return rangenerator;
 }
@@ -298,18 +296,18 @@ void RepExMove2::setSwapMonitors(bool swap)
 bool replicaTest(Replica &replica_a, Replica &replica_b,
                  const RanGenerator &rangenerator)
 {
-    //get the ensembles of the two replicas
+    // get the ensembles of the two replicas
     const Ensemble &ensemble_a = replica_a.ensemble();
     const Ensemble &ensemble_b = replica_b.ensemble();
 
-    if ( (ensemble_a.isNVT() and ensemble_a.isNVT()) or
-         (ensemble_b.isNPT() and ensemble_b.isNPT()) )
+    if ((ensemble_a.isNVT() and ensemble_a.isNVT()) or
+        (ensemble_b.isNPT() and ensemble_b.isNPT()))
     {
         bool need_pv = (ensemble_a.isNPT() and ensemble_b.isNPT());
 
-        //get the values of the thermodynamic parameters
-        double beta_a = 1.0 / (k_boltz * ensemble_a.temperature()).value();
-        double beta_b = 1.0 / (k_boltz * ensemble_b.temperature()).value();
+        // get the values of the thermodynamic parameters
+        double beta_a = 1.0 / (k_boltz.value() * ensemble_a.temperature()).value();
+        double beta_b = 1.0 / (k_boltz.value() * ensemble_b.temperature()).value();
 
         Pressure p_a(0);
         Pressure p_b(0);
@@ -320,8 +318,8 @@ bool replicaTest(Replica &replica_a, Replica &replica_b,
             p_b = ensemble_b.pressure();
         }
 
-        //now get the values of the system properties at their current state,
-        //and at their swapped states
+        // now get the values of the system properties at their current state,
+        // and at their swapped states
         double H_a_i = replica_a.energy().value();
         double H_b_i = replica_b.energy().value();
 
@@ -331,17 +329,17 @@ bool replicaTest(Replica &replica_a, Replica &replica_b,
         if (replica_a.lambdaValue() != replica_b.lambdaValue() or
             replica_a.energyComponent() != replica_b.energyComponent())
         {
-            //there will be a change in energy associated with the swap
+            // there will be a change in energy associated with the swap
             System swapped = replica_a.subSystem();
 
-            //evaluate the energy of replica A swapped into the B state
+            // evaluate the energy of replica A swapped into the B state
             swapped.setComponent(replica_a.lambdaComponent(), replica_b.lambdaValue());
-            H_a_j = swapped.energy( replica_b.energyComponent() ).value();
+            H_a_j = swapped.energy(replica_b.energyComponent()).value();
 
-            //evaluate the energy of replica B swapped into the A state
+            // evaluate the energy of replica B swapped into the A state
             swapped = replica_b.subSystem();
             swapped.setComponent(replica_b.lambdaComponent(), replica_a.lambdaValue());
-            H_b_j = swapped.energy( replica_a.energyComponent() ).value();
+            H_b_j = swapped.energy(replica_a.energyComponent()).value();
         }
 
         double V_a_i(0);
@@ -360,37 +358,35 @@ bool replicaTest(Replica &replica_a, Replica &replica_b,
 
             if (replica_a.spaceProperty() != replica_b.spaceProperty())
             {
-                //the space property changes, so volume could change
-                V_a_j = replica_a.subSystem().property(replica_b.spaceProperty())
-                                 .asA<Space>().volume().value();
+                // the space property changes, so volume could change
+                V_a_j = replica_a.subSystem().property(replica_b.spaceProperty()).asA<Space>().volume().value();
 
-                V_b_j = replica_b.subSystem().property(replica_a.spaceProperty())
-                                 .asA<Space>().volume().value();
+                V_b_j = replica_b.subSystem().property(replica_a.spaceProperty()).asA<Space>().volume().value();
             }
         }
 
-        //now calculate delta needed for the Monte Carlo test
+        // now calculate delta needed for the Monte Carlo test
         //
-        //  For derivation see Appendix C of Christopher Woods' thesis
-        //   (or original replica exchange literature of course!)
+        //   For derivation see Appendix C of Christopher Woods' thesis
+        //    (or original replica exchange literature of course!)
         //
-        //  delta = beta_b * [ H_b_i - H_b_j + P_b (V_b_i - V_b_j) ] +
-        //          beta_a * [ H_a_i - H_a_j + P_a (V_a_i - V_a_j) ]
+        //   delta = beta_b * [ H_b_i - H_b_j + P_b (V_b_i - V_b_j) ] +
+        //           beta_a * [ H_a_i - H_a_j + P_a (V_a_i - V_a_j) ]
 
-        double delta = beta_b * ( H_b_i - H_b_j + p_b*(V_b_i - V_b_j) ) +
-                       beta_a * ( H_a_i - H_a_j + p_a*(V_a_i - V_a_j) );
+        double delta = beta_b * (H_b_i - H_b_j + p_b * (V_b_i - V_b_j)) +
+                       beta_a * (H_a_i - H_a_j + p_a * (V_a_i - V_a_j));
 
-        bool move_passed = ( delta > 0 or (std::exp(delta) >= rangenerator.rand()) );
+        bool move_passed = (delta > 0 or (std::exp(delta) >= rangenerator.rand()));
 
         return move_passed;
     }
     else
     {
-        throw SireError::incompatible_error( QObject::tr(
-            "There is no available replica exchange test that allows tests between "
-            "replicas with ensembles %1 and %2.")
-                .arg(ensemble_a.toString(), ensemble_b.toString()), CODELOC );
-
+        throw SireError::incompatible_error(QObject::tr(
+                                                "There is no available replica exchange test that allows tests between "
+                                                "replicas with ensembles %1 and %2.")
+                                                .arg(ensemble_a.toString(), ensemble_b.toString()),
+                                            CODELOC);
     }
 
     return false;
@@ -559,11 +555,11 @@ bool replicaTest(Replica &replica_a, Replica &replica_b,
 void RepExMove2::performMove(Replicas &replicas, bool record_stats)
 {
     throw SireError::incomplete_code(
-            QObject::tr("tbb has removed tbb::task, so we now need to "
-                        "rewrite RepExMove2. If this affects you, "
-                        "please switch to RepExMove, and then raise "
-                        "a GitHub issue asking us to conduct a rewrite."),
-                        CODELOC);
+        QObject::tr("tbb has removed tbb::task, so we now need to "
+                    "rewrite RepExMove2. If this affects you, "
+                    "please switch to RepExMove, and then raise "
+                    "a GitHub issue asking us to conduct a rewrite."),
+        CODELOC);
     /*
     if (replicas.nReplicas() == 0)
         return;
@@ -658,14 +654,14 @@ void RepExMove2::move(SupraSystem &system, int nmoves, bool record_stats)
 
     try
     {
-        for (int i=0; i<nmoves; ++i)
+        for (int i = 0; i < nmoves; ++i)
         {
             this->performMove(replicas, record_stats);
         }
 
         SupraMove::incrementNMoves(nmoves);
     }
-    catch(...)
+    catch (...)
     {
         replicas.copy(*old_replicas);
         this->copy(*old_state);
@@ -673,9 +669,7 @@ void RepExMove2::move(SupraSystem &system, int nmoves, bool record_stats)
     }
 }
 
-const char* RepExMove2::typeName()
+const char *RepExMove2::typeName()
 {
-    return QMetaType::typeName( qMetaTypeId<RepExMove2>() );
+    return QMetaType::typeName(qMetaTypeId<RepExMove2>());
 }
-
-
diff --git a/corelib/src/libs/SireUnits/dimensions.h b/corelib/src/libs/SireUnits/dimensions.h
index 6098529ad..14ef5a57d 100644
--- a/corelib/src/libs/SireUnits/dimensions.h
+++ b/corelib/src/libs/SireUnits/dimensions.h
@@ -39,436 +39,453 @@ SIRE_BEGIN_HEADER
 
 namespace SireUnits
 {
-namespace Dimension
-{
-class Unit;
-class GeneralUnit;
-}
-}
-
-QDataStream& operator<<(QDataStream&, const SireUnits::Dimension::Unit&);
-QDataStream& operator>>(QDataStream&, SireUnits::Dimension::Unit&);
-
-namespace SireUnits
-{
-
-using SireMaths::pi;
-
-
-namespace Dimension
-{
-
-class TempBase;
-
-/** This is the base class of all units - at its heart, this is
-    just a scale factor - how many times the base unit is the
-    current value.
-
-    @author Christopher Woods
-*/
-class SIREUNITS_EXPORT Unit
-{
-
-friend SIREUNITS_EXPORT QDataStream& ::operator<<(QDataStream&, const Unit&);
-friend SIREUNITS_EXPORT QDataStream& ::operator>>(QDataStream&, Unit&);
-
-public:
-    ~Unit()
-    {}
-
-    operator double() const
-    {
-        return sclfac;
-    }
-
-    double value() const
-    {
-        return sclfac;
-    }
-
-    double scaleFactor() const
-    {
-        return sclfac;
-    }
-
-    double convertToInternal(double value) const
-    {
-        return value * sclfac;
-    }
-
-    double convertFromInternal(double value) const
-    {
-        return value / sclfac;
-    }
-
-protected:
-    Unit(double scale_factor) : sclfac(scale_factor)
-    {}
-
-    Unit(const TempBase &temperature);
-
-    void setScale(double scale_factor)
-    {
-        sclfac = scale_factor;
-    }
-
-private:
-    double sclfac;
-};
-
-SIREUNITS_EXPORT QPair<double, QString> getUnitString(
-                            int M, int L, int T, int C, int t, int Q, int A);
-
-/** Construct a physical unit with the specified
-    Mass, Length, Time, Charge, temperature,
-    Quantity and Angle dimensions
-
-    @author Christopher Woods
-*/
-template<int M, int L, int T,
-         int C, int t, int Q, int A>
-class PhysUnit : public Unit
-{
-public:
-    PhysUnit() : Unit(0)
-    {}
-
-    explicit PhysUnit(double scale_factor)
-               : Unit(scale_factor)
-    {}
-
-    explicit PhysUnit(const TempBase &temperature) : Unit(temperature)
-    {
-        //this must be a Temperature!
-        //BOOST_STATIC_ASSERT( t == 1 and M == 0 and L == 0 and
-        //                     T == 0 and C == 0 and Q == 0 and A == 0);
-    }
-
-    PhysUnit(const GeneralUnit &other);
-
-    PhysUnit(const PhysUnit<M,L,T,C,t,Q,A> &other)
-               : Unit(other)
-    {}
-
-    ~PhysUnit()
-    {}
-
-    static const char* typeName()
-    {
-        return QMetaType::typeName( qMetaTypeId< PhysUnit<M,L,T,C,t,Q,A> >() );
-    }
-
-    const char* what() const
-    {
-        return PhysUnit<M,L,T,C,t,Q,A>::typeName();
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A>&
-    operator=(const PhysUnit<M,L,T,C,t,Q,A> &other)
-    {
-        Unit::setScale(other.scaleFactor());
-        return *this;
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A>&
-    operator=(const GeneralUnit &other);
-
-    bool operator==(const PhysUnit<M,L,T,C,t,Q,A> &other) const
-    {
-        return scaleFactor() == other.scaleFactor();
-    }
-
-    bool operator!=(const PhysUnit<M,L,T,C,t,Q,A> &other) const
-    {
-        return scaleFactor() != other.scaleFactor();
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A> operator-() const
-    {
-        return PhysUnit<M,L,T,C,t,Q,A>( -scaleFactor() );
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A>
-    operator+(const PhysUnit<M,L,T,C,t,Q,A> &other) const
-    {
-        return PhysUnit<M,L,T,C,t,Q,A>(
-                  scaleFactor() + other.scaleFactor());
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A>
-    operator-(const PhysUnit<M,L,T,C,t,Q,A> &other) const
-    {
-        return PhysUnit<M,L,T,C,t,Q,A>(
-                  scaleFactor() - other.scaleFactor());
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A>&
-    operator+=(const PhysUnit<M,L,T,C,t,Q,A> &other)
-    {
-        Unit::setScale( scaleFactor() + other.scaleFactor() );
-        return *this;
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A>&
-    operator-=(const PhysUnit<M,L,T,C,t,Q,A> &other)
+    namespace Dimension
     {
-        Unit::setScale( scaleFactor() - other.scaleFactor() );
-        return *this;
+        class Unit;
+        class GeneralUnit;
     }
-
-    PhysUnit<M,L,T,C,t,Q,A> operator*(double val) const
-    {
-        return PhysUnit<M,L,T,C,t,Q,A>(scaleFactor() * val);
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A>& operator*=(double val)
-    {
-        Unit::setScale( scaleFactor() * val );
-        return *this;
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A>& operator/=(double val)
-    {
-        Unit::setScale( scaleFactor() / val );
-        return *this;
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A>& operator*=(int val)
-    {
-        Unit::setScale( scaleFactor() * val );
-        return *this;
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A>& operator/=(int val)
-    {
-        Unit::setScale( scaleFactor() / val );
-        return *this;
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A> operator/(double val) const
-    {
-        return PhysUnit<M,L,T,C,t,Q,A>(scaleFactor() / val);
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A> operator*(int val) const
-    {
-        return PhysUnit<M,L,T,C,t,Q,A>(scaleFactor() * val);
-    }
-
-    PhysUnit<M,L,T,C,t,Q,A> operator/(int val) const
-    {
-        return PhysUnit<M,L,T,C,t,Q,A>(scaleFactor() / val);
-    }
-
-    template<int _M, int _L, int _T,
-             int _C, int _t, int _Q, int _A>
-    PhysUnit<M+_M, L+_L, T+_T, C+_C, t+_t, Q+_Q, A+_A>
-    operator*(const PhysUnit<_M,_L,_T,_C,_t,_Q,_A> &other) const
-    {
-        return PhysUnit<M+_M,L+_L,T+_T,C+_C,t+_t,Q+_Q,A+_A>(
-                  scaleFactor() * other.scaleFactor());
-    }
-
-    template<int _M, int _L, int _T,
-             int _C, int _t, int _Q, int _A>
-    PhysUnit<M-_M, L-_L, T-_T, C-_C, t-_t, Q-_Q, A-_A>
-    operator/(const PhysUnit<_M,_L,_T,_C,_t,_Q,_A> &other) const
-    {
-        return PhysUnit<M-_M,L-_L,T-_T,C-_C,t-_t,Q-_Q,A-_A>(
-                  scaleFactor() / other.scaleFactor());
-    }
-
-    PhysUnit<-M,-L,-T,-C,-t,-Q,-A> invert() const
-    {
-        return PhysUnit<-M,-L,-T,-C,-t,-Q,-A>( 1.0 / scaleFactor() );
-    }
-
-    double in(const PhysUnit<M,L,T,C,t,Q,A> &units) const
-    {
-        return units.convertFromInternal(*this);
-    }
-
-    double to(const PhysUnit<M,L,T,C,t,Q,A> &units) const
-    {
-        return this->in(units);
-    }
-
-    QString unitString() const
-    {
-        return SireUnits::Dimension::getUnitString(M, L, T, C, t, Q, A).second;
-    }
-
-    QString toString() const
-    {
-        auto u = SireUnits::Dimension::getUnitString(M, L, T, C, t, Q, A);
-
-        double v = value() / u.first;
-
-        if (u.second.startsWith("°"))
-            return QString("%1%2").arg(v).arg(u.second);
-        else
-            return QString("%1 %2").arg(v).arg(u.second);
-    }
-
-    static int MASS()
-    {
-        return M;
-    }
-
-    static int LENGTH()
-    {
-        return L;
-    }
-
-    static int TIME()
-    {
-        return T;
-    }
-
-    static int CHARGE()
-    {
-        return C;
-    }
-
-    static int TEMPERATURE()
-    {
-        return t;
-    }
-
-    static int QUANTITY()
-    {
-        return Q;
-    }
-
-    static int ANGLE()
-    {
-        return A;
-    }
-};
-
-template<int M, int L, int T, int C, int t, int Q, int A>
-PhysUnit<M,L,T,C,t,Q,A>
-operator*(double val, const PhysUnit<M,L,T,C,t,Q,A> &unit)
-{
-    return PhysUnit<M,L,T,C,t,Q,A>( val * unit.scaleFactor() );
 }
 
-template<int M, int L, int T, int C, int t, int Q, int A>
-PhysUnit<M,L,T,C,t,Q,A>
-operator*(int val, const PhysUnit<M,L,T,C,t,Q,A> &unit)
-{
-    return PhysUnit<M,L,T,C,t,Q,A>( val * unit.scaleFactor() );
-}
+QDataStream &operator<<(QDataStream &, const SireUnits::Dimension::Unit &);
+QDataStream &operator>>(QDataStream &, SireUnits::Dimension::Unit &);
 
-template<int M, int L, int T, int C, int t, int Q, int A>
-PhysUnit<-M,-L,-T,-C,-t,-Q,-A>
-operator/(double val, const PhysUnit<M,L,T,C,t,Q,A> &unit)
+namespace SireUnits
 {
-    return PhysUnit<-M,-L,-T,-C,-t,-Q,-A>( val / unit.scaleFactor() );
-}
 
-template<int M, int L, int T, int C, int t, int Q, int A>
-PhysUnit<-M,-L,-T,-C,-t,-Q,-A>
-operator/(int val, const PhysUnit<M,L,T,C,t,Q,A> &unit)
-{
-    return PhysUnit<-M,-L,-T,-C,-t,-Q,-A>( val / unit.scaleFactor() );
-}
+    using SireMaths::pi;
+
+    namespace Dimension
+    {
+
+        class TempBase;
+
+        /** This is the base class of all units - at its heart, this is
+            just a scale factor - how many times the base unit is the
+            current value.
+
+            @author Christopher Woods
+        */
+        class SIREUNITS_EXPORT Unit
+        {
+
+            friend SIREUNITS_EXPORT QDataStream & ::operator<<(QDataStream &, const Unit &);
+            friend SIREUNITS_EXPORT QDataStream & ::operator>>(QDataStream &, Unit &);
+
+        public:
+            ~Unit()
+            {
+            }
+
+            operator double() const
+            {
+                return sclfac;
+            }
+
+            double value() const
+            {
+                return sclfac;
+            }
+
+            double scaleFactor() const
+            {
+                return sclfac;
+            }
+
+            double convertToInternal(double value) const
+            {
+                return value * sclfac;
+            }
+
+            double convertFromInternal(double value) const
+            {
+                return value / sclfac;
+            }
+
+        protected:
+            Unit(double scale_factor) : sclfac(scale_factor)
+            {
+            }
+
+            Unit(const TempBase &temperature);
+
+            void setScale(double scale_factor)
+            {
+                sclfac = scale_factor;
+            }
+
+        private:
+            double sclfac;
+        };
+
+        SIREUNITS_EXPORT QPair<double, QString> getUnitString(
+            int M, int L, int T, int C, int t, int Q, int A);
+
+        /** Construct a physical unit with the specified
+            Mass, Length, Time, Charge, temperature,
+            Quantity and Angle dimensions
+
+            @author Christopher Woods
+        */
+        template <int M, int L, int T,
+                  int C, int t, int Q, int A>
+        class PhysUnit : public Unit
+        {
+        public:
+            PhysUnit() : Unit(0)
+            {
+            }
+
+            explicit PhysUnit(double scale_factor)
+                : Unit(scale_factor)
+            {
+            }
+
+            explicit PhysUnit(const TempBase &temperature) : Unit(temperature)
+            {
+                // this must be a Temperature!
+                // BOOST_STATIC_ASSERT( t == 1 and M == 0 and L == 0 and
+                //                      T == 0 and C == 0 and Q == 0 and A == 0);
+            }
+
+            PhysUnit(const GeneralUnit &other);
+
+            PhysUnit(const PhysUnit<M, L, T, C, t, Q, A> &other)
+                : Unit(other)
+            {
+            }
+
+            ~PhysUnit()
+            {
+            }
+
+            static const char *typeName()
+            {
+                return QMetaType::typeName(qMetaTypeId<PhysUnit<M, L, T, C, t, Q, A>>());
+            }
+
+            const char *what() const
+            {
+                return PhysUnit<M, L, T, C, t, Q, A>::typeName();
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> &
+            operator=(const PhysUnit<M, L, T, C, t, Q, A> &other)
+            {
+                Unit::setScale(other.scaleFactor());
+                return *this;
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> &
+            operator=(const GeneralUnit &other);
+
+            bool operator==(const PhysUnit<M, L, T, C, t, Q, A> &other) const
+            {
+                return scaleFactor() == other.scaleFactor();
+            }
+
+            bool operator!=(const PhysUnit<M, L, T, C, t, Q, A> &other) const
+            {
+                return scaleFactor() != other.scaleFactor();
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> operator-() const
+            {
+                return PhysUnit<M, L, T, C, t, Q, A>(-scaleFactor());
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A>
+            operator+(const PhysUnit<M, L, T, C, t, Q, A> &other) const
+            {
+                return PhysUnit<M, L, T, C, t, Q, A>(
+                    scaleFactor() + other.scaleFactor());
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A>
+            operator-(const PhysUnit<M, L, T, C, t, Q, A> &other) const
+            {
+                return PhysUnit<M, L, T, C, t, Q, A>(
+                    scaleFactor() - other.scaleFactor());
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> &
+            operator+=(const PhysUnit<M, L, T, C, t, Q, A> &other)
+            {
+                Unit::setScale(scaleFactor() + other.scaleFactor());
+                return *this;
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> &
+            operator-=(const PhysUnit<M, L, T, C, t, Q, A> &other)
+            {
+                Unit::setScale(scaleFactor() - other.scaleFactor());
+                return *this;
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> operator*(double val) const
+            {
+                return PhysUnit<M, L, T, C, t, Q, A>(scaleFactor() * val);
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> &operator*=(double val)
+            {
+                Unit::setScale(scaleFactor() * val);
+                return *this;
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> &operator/=(double val)
+            {
+                Unit::setScale(scaleFactor() / val);
+                return *this;
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> &operator*=(int val)
+            {
+                Unit::setScale(scaleFactor() * val);
+                return *this;
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> &operator/=(int val)
+            {
+                Unit::setScale(scaleFactor() / val);
+                return *this;
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> operator/(double val) const
+            {
+                return PhysUnit<M, L, T, C, t, Q, A>(scaleFactor() / val);
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> operator*(int val) const
+            {
+                return PhysUnit<M, L, T, C, t, Q, A>(scaleFactor() * val);
+            }
+
+            PhysUnit<M, L, T, C, t, Q, A> operator/(int val) const
+            {
+                return PhysUnit<M, L, T, C, t, Q, A>(scaleFactor() / val);
+            }
+
+            template <int _M, int _L, int _T,
+                      int _C, int _t, int _Q, int _A>
+            PhysUnit<M + _M, L + _L, T + _T, C + _C, t + _t, Q + _Q, A + _A>
+            operator*(const PhysUnit<_M, _L, _T, _C, _t, _Q, _A> &other) const
+            {
+                return PhysUnit<M + _M, L + _L, T + _T, C + _C, t + _t, Q + _Q, A + _A>(
+                    scaleFactor() * other.scaleFactor());
+            }
+
+            template <int _M, int _L, int _T,
+                      int _C, int _t, int _Q, int _A>
+            PhysUnit<M - _M, L - _L, T - _T, C - _C, t - _t, Q - _Q, A - _A>
+            operator/(const PhysUnit<_M, _L, _T, _C, _t, _Q, _A> &other) const
+            {
+                return PhysUnit<M - _M, L - _L, T - _T, C - _C, t - _t, Q - _Q, A - _A>(
+                    scaleFactor() / other.scaleFactor());
+            }
+
+            PhysUnit<-M, -L, -T, -C, -t, -Q, -A> invert() const
+            {
+                return PhysUnit<-M, -L, -T, -C, -t, -Q, -A>(1.0 / scaleFactor());
+            }
+
+            double in(const PhysUnit<M, L, T, C, t, Q, A> &units) const
+            {
+                return units.convertFromInternal(*this);
+            }
+
+            double to(const PhysUnit<M, L, T, C, t, Q, A> &units) const
+            {
+                return this->in(units);
+            }
+
+            QString unitString() const
+            {
+                return SireUnits::Dimension::getUnitString(M, L, T, C, t, Q, A).second;
+            }
+
+            QString toString() const
+            {
+                auto u = SireUnits::Dimension::getUnitString(M, L, T, C, t, Q, A);
+
+                double v = value() / u.first;
+
+                if (u.second.startsWith("°"))
+                    return QString("%1%2").arg(v).arg(u.second);
+                else
+                    return QString("%1 %2").arg(v).arg(u.second);
+            }
+
+            static int MASS()
+            {
+                return M;
+            }
+
+            static int LENGTH()
+            {
+                return L;
+            }
+
+            static int TIME()
+            {
+                return T;
+            }
+
+            static int CHARGE()
+            {
+                return C;
+            }
+
+            static int TEMPERATURE()
+            {
+                return t;
+            }
+
+            static int QUANTITY()
+            {
+                return Q;
+            }
+
+            static int ANGLE()
+            {
+                return A;
+            }
+        };
+
+        template <int M, int L, int T, int C, int t, int Q, int A>
+        PhysUnit<M, L, T, C, t, Q, A>
+        operator*(double val, const PhysUnit<M, L, T, C, t, Q, A> &unit)
+        {
+            return PhysUnit<M, L, T, C, t, Q, A>(val * unit.scaleFactor());
+        }
+
+        template <int M, int L, int T, int C, int t, int Q, int A>
+        PhysUnit<M, L, T, C, t, Q, A>
+        operator*(int val, const PhysUnit<M, L, T, C, t, Q, A> &unit)
+        {
+            return PhysUnit<M, L, T, C, t, Q, A>(val * unit.scaleFactor());
+        }
+
+        template <int M, int L, int T, int C, int t, int Q, int A>
+        PhysUnit<-M, -L, -T, -C, -t, -Q, -A>
+        operator/(double val, const PhysUnit<M, L, T, C, t, Q, A> &unit)
+        {
+            return PhysUnit<-M, -L, -T, -C, -t, -Q, -A>(val / unit.scaleFactor());
+        }
+
+        template <int M, int L, int T, int C, int t, int Q, int A>
+        PhysUnit<-M, -L, -T, -C, -t, -Q, -A>
+        operator/(int val, const PhysUnit<M, L, T, C, t, Q, A> &unit)
+        {
+            return PhysUnit<-M, -L, -T, -C, -t, -Q, -A>(val / unit.scaleFactor());
+        }
 
 /** Typedef the various unit dimensions (including derived units) */
 #ifndef SKIP_BROKEN_GCCXML_PARTS
-typedef PhysUnit<0,0,0,0,0,0,0> Dimensionless;
+        typedef PhysUnit<0, 0, 0, 0, 0, 0, 0> Dimensionless;
+
+        typedef PhysUnit<1, 0, 0, 0, 0, 0, 0> Mass;
 
-typedef PhysUnit<1,0,0,0,0,0,0> Mass;
+        typedef PhysUnit<1, 0, 0, 0, 0, -1, 0> MolarMass;
 
-typedef PhysUnit<1,0,0,0,0,-1,0> MolarMass;
+        typedef PhysUnit<0, 1, 0, 0, 0, 0, 0> Length;
 
-typedef PhysUnit<0,1,0,0,0,0,0> Length;
+        typedef PhysUnit<0, 0, 1, 0, 0, 0, 0> Time;
 
-typedef PhysUnit<0,0,1,0,0,0,0> Time;
+        typedef PhysUnit<0, 0, 0, 1, 0, 0, 0> Charge;
 
-typedef PhysUnit<0,0,0,1,0,0,0> Charge;
+        typedef PhysUnit<0, 0, 0, 1, 0, -1, 0> MolarCharge;
 
-typedef PhysUnit<0,0,0,1,0,-1,0> MolarCharge;
+        typedef PhysUnit<0, 0, 0, 0, 1, 0, 0> Temperature;
 
-typedef PhysUnit<0,0,0,0,1,0,0> Temperature;
+        typedef PhysUnit<0, 0, 0, 0, 0, 1, 0> Quantity;
 
-typedef PhysUnit<0,0,0,0,0,1,0> Quantity;
+        typedef PhysUnit<0, 0, 0, 0, 0, 0, 1> Angle;
 
-typedef PhysUnit<0,0,0,0,0,0,1> Angle;
+        typedef PhysUnit<0, 2, 0, 0, 0, 0, 0> Area;
 
-typedef PhysUnit<0,2,0,0,0,0,0> Area;
+        typedef PhysUnit<0, 3, 0, 0, 0, 0, 0> Volume;
 
-typedef PhysUnit<0,3,0,0,0,0,0> Volume;
+        typedef PhysUnit<0, 3, 0, 0, 0, -1, 0> MolarVolume;
 
-typedef PhysUnit<0,3,0,0,0,-1,0> MolarVolume;
+        typedef PhysUnit<0, 1, -1, 0, 0, 0, 0> Velocity;
 
-typedef PhysUnit<0,1,-1,0,0,0,0> Velocity;
+        typedef PhysUnit<0, 0, -1, 0, 0, 0, 1> AngularVelocity;
 
-typedef PhysUnit<0,0,-1,0,0,0,1> AngularVelocity;
+        typedef PhysUnit<0, 1, -2, 0, 0, 0, 0> Acceleration;
 
-typedef PhysUnit<0,1,-2,0,0,0,0> Acceleration;
+        typedef PhysUnit<0, 0, -2, 0, 0, 0, 1> AngularAcceleration;
 
-typedef PhysUnit<0,0,-2,0,0,0,1> AngularAcceleration;
+        typedef PhysUnit<1, 2, -2, 0, 0, 0, 0> Energy;
 
-typedef PhysUnit<1,2,-2,0,0,0,0> Energy;
+        typedef PhysUnit<1, 2, -2, 0, 0, -1, 0> MolarEnergy;
 
-typedef PhysUnit<1,2,-2,0,0,-1,0> MolarEnergy;
+        typedef PhysUnit<1, 2, -3, 0, 0, 0, 0> Power;
 
-typedef PhysUnit<1,2,-3,0,0,0,0> Power;
+        typedef PhysUnit<1, 2, -3, 0, 0, -1, 0> MolarPower;
 
-typedef PhysUnit<1,2,-3,0,0,-1,0> MolarPower;
+        typedef PhysUnit<1, -3, 0, 0, 0, 0, 0> Density;
 
-typedef PhysUnit<1,-3,0,0,0,0,0> Density;
+        typedef PhysUnit<1, -3, 0, 0, 0, -1, 0> MolarDensity;
 
-typedef PhysUnit<1,-3,0,0,0,-1,0> MolarDensity;
+        typedef PhysUnit<1, 1, -2, 0, 0, 0, 0> Force;
 
-typedef PhysUnit<1,1,-2,0,0,0,0> Force;
+        typedef PhysUnit<1, -1, -2, 0, 0, 0, 0> Pressure;
 
-typedef PhysUnit<1,-1,-2,0,0,0,0> Pressure;
+        typedef PhysUnit<0, 0, -1, 1, 0, 0, 0> Current;
+        typedef PhysUnit<-1, -2, 2, 2, 0, 0, 0> Capacitance;
+        typedef PhysUnit<1, 2, -2, -1, 0, 0, 0> Potential;
 
-typedef PhysUnit<0,0,-1,1,0,0,0> Current;
-typedef PhysUnit<-1,-2,2,2,0,0,0> Capacitance;
-typedef PhysUnit<1,2,-2,-1,0,0,0> Potential;
+        typedef PhysUnit<-1, -3, 2, 2, 0, 0, 0> Constant1;
+        typedef PhysUnit<1, 2, -1, 0, 0, 0, 0> Constant2;
+        typedef PhysUnit<1, 1, 0, -2, 0, 0, 0> Constant3;
+        typedef PhysUnit<-1, 3, -2, 0, 0, 0, 0> Constant4;
+        typedef PhysUnit<1, 2, -2, 0, -1, -1, 0> Constant5;
 
 #else // else with 'ifndef SKIP_BROKEN_GCCXML_PARTS'
 
-class Dimensionless;
-class Mass;
-class MolarMass;
-class Length;
-class Time;
-class Charge;
-class MolarCharge;
-class Temperature;
-class Quantity;
-class Angle;
-class Area;
-class Volume;
-class MolarVolume;
-class Velocity;
-class Acceleration;
-class Energy;
-class MolarEnergy;
-class Power;
-class MolarPower;
-class Density;
-class MolarDensity;
-class Force;
-class Pressure;
-class Capacitance;
-class Current;
-class Potential;
+        class Dimensionless;
+        class Mass;
+        class MolarMass;
+        class Length;
+        class Time;
+        class Charge;
+        class MolarCharge;
+        class Temperature;
+        class Quantity;
+        class Angle;
+        class Area;
+        class Volume;
+        class MolarVolume;
+        class Velocity;
+        class Acceleration;
+        class Energy;
+        class MolarEnergy;
+        class Power;
+        class MolarPower;
+        class Density;
+        class MolarDensity;
+        class Force;
+        class Pressure;
+        class Capacitance;
+        class Current;
+        class Potential;
+
+        class Constant1;
+        class Constant2;
+        class Constant3;
+        class Constant4;
+        class Constant5;
 
 #endif // end of 'ifndef SKIP_BROKEN_GCCXML_PARTS'
 
-} // end of namespace Dimension
+    } // end of namespace Dimension
 
 }
 
 /** Serialise a unit to a binary datastream (this does not check
     the type of unit!) */
-SIRE_ALWAYS_INLINE QDataStream& operator<<(QDataStream &ds,
-                               const SireUnits::Dimension::Unit &unit)
+SIRE_ALWAYS_INLINE QDataStream &operator<<(QDataStream &ds,
+                                           const SireUnits::Dimension::Unit &unit)
 {
     ds << unit.sclfac;
     return ds;
@@ -476,43 +493,49 @@ SIRE_ALWAYS_INLINE QDataStream& operator<<(QDataStream &ds,
 
 /** Extract from a binary datastream (this does not check the type
     of unit!) */
-SIRE_ALWAYS_INLINE QDataStream& operator>>(QDataStream &ds,
-                               SireUnits::Dimension::Unit &unit)
+SIRE_ALWAYS_INLINE QDataStream &operator>>(QDataStream &ds,
+                                           SireUnits::Dimension::Unit &unit)
 {
     ds >> unit.sclfac;
     return ds;
 }
 
-Q_DECLARE_METATYPE( SireUnits::Dimension::Dimensionless );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Mass );
-Q_DECLARE_METATYPE( SireUnits::Dimension::MolarMass );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Length );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Time );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Charge );
-Q_DECLARE_METATYPE( SireUnits::Dimension::MolarCharge );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Temperature );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Quantity );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Angle );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Area );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Volume );
-Q_DECLARE_METATYPE( SireUnits::Dimension::MolarVolume );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Velocity );
-Q_DECLARE_METATYPE( SireUnits::Dimension::AngularVelocity );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Acceleration );
-Q_DECLARE_METATYPE( SireUnits::Dimension::AngularAcceleration );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Energy );
-Q_DECLARE_METATYPE( SireUnits::Dimension::MolarEnergy );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Power );
-Q_DECLARE_METATYPE( SireUnits::Dimension::MolarPower );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Density );
-Q_DECLARE_METATYPE( SireUnits::Dimension::MolarDensity );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Force );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Pressure );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Capacitance );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Current );
-Q_DECLARE_METATYPE( SireUnits::Dimension::Potential );
-
-SIRE_EXPOSE_CLASS( SireUnits::Dimension::Unit )
+Q_DECLARE_METATYPE(SireUnits::Dimension::Dimensionless);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Mass);
+Q_DECLARE_METATYPE(SireUnits::Dimension::MolarMass);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Length);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Time);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Charge);
+Q_DECLARE_METATYPE(SireUnits::Dimension::MolarCharge);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Temperature);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Quantity);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Angle);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Area);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Volume);
+Q_DECLARE_METATYPE(SireUnits::Dimension::MolarVolume);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Velocity);
+Q_DECLARE_METATYPE(SireUnits::Dimension::AngularVelocity);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Acceleration);
+Q_DECLARE_METATYPE(SireUnits::Dimension::AngularAcceleration);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Energy);
+Q_DECLARE_METATYPE(SireUnits::Dimension::MolarEnergy);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Power);
+Q_DECLARE_METATYPE(SireUnits::Dimension::MolarPower);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Density);
+Q_DECLARE_METATYPE(SireUnits::Dimension::MolarDensity);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Force);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Pressure);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Capacitance);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Current);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Potential);
+
+Q_DECLARE_METATYPE(SireUnits::Dimension::Constant1);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Constant2);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Constant3);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Constant4);
+Q_DECLARE_METATYPE(SireUnits::Dimension::Constant5);
+
+SIRE_EXPOSE_CLASS(SireUnits::Dimension::Unit)
 
 SIRE_END_HEADER
 
diff --git a/corelib/src/libs/SireUnits/generalunit.cpp b/corelib/src/libs/SireUnits/generalunit.cpp
index b3a5db21f..c4930c84b 100644
--- a/corelib/src/libs/SireUnits/generalunit.cpp
+++ b/corelib/src/libs/SireUnits/generalunit.cpp
@@ -22,7 +22,7 @@ using namespace SireStream;
 
 static const RegisterMetaType<GeneralUnit> r_genunit(NO_ROOT);
 
-QDataStream& operator<<(QDataStream &ds, const SireUnits::Dimension::GeneralUnit &u)
+QDataStream &operator<<(QDataStream &ds, const SireUnits::Dimension::GeneralUnit &u)
 {
     writeHeader(ds, r_genunit, 1);
 
@@ -38,12 +38,12 @@ QDataStream& operator<<(QDataStream &ds, const SireUnits::Dimension::GeneralUnit
 
     sds << u.comps
         << a << c << l << m << t1 << t2 << q
-        << static_cast<const Unit&>(u);
+        << static_cast<const Unit &>(u);
 
     return ds;
 }
 
-QDataStream& operator>>(QDataStream &ds, SireUnits::Dimension::GeneralUnit &u)
+QDataStream &operator>>(QDataStream &ds, SireUnits::Dimension::GeneralUnit &u)
 {
     VersionID v = readHeader(ds, r_genunit);
 
@@ -53,9 +53,7 @@ QDataStream& operator>>(QDataStream &ds, SireUnits::Dimension::GeneralUnit &u)
 
         SharedDataStream sds(ds);
 
-        sds >> u.comps
-            >> a >> c >> l >> m >> t1 >> t2 >> q
-            >> static_cast<Unit&>(u);
+        sds >> u.comps >> a >> c >> l >> m >> t1 >> t2 >> q >> static_cast<Unit &>(u);
 
         u.Angle = a;
         u.Charge = c;
@@ -73,50 +71,60 @@ QDataStream& operator>>(QDataStream &ds, SireUnits::Dimension::GeneralUnit &u)
 
 namespace SireUnits
 {
-namespace Dimension
-{
-namespace detail
-{
-
-static QHash<QString,QString> typename_registry;
-static QMutex registry_mutex;
-
-static QString getKey(const GeneralUnit &unit)
-{
-    return QString("%1-%2-%3-%4-%5-%6-%7")
-              .arg(unit.MASS()).arg(unit.LENGTH()).arg(unit.TIME())
-              .arg(unit.CHARGE()).arg(unit.TEMPERATURE())
-              .arg(unit.QUANTITY()).arg(unit.ANGLE());
-}
-
-void SIREUNITS_EXPORT registerTypeName(const GeneralUnit &unit, const char *typnam)
-{
-    QString key = getKey(unit);
-
-    QMutexLocker lkr(&registry_mutex);
-    if (not typename_registry.contains(key))
+    namespace Dimension
     {
-        typename_registry.insert( key, QString(typnam) );
-    }
-}
-
-static QString getTypeName(const GeneralUnit &unit)
-{
-    QString key = getKey(unit);
-
-    QMutexLocker lkr(&registry_mutex);
-
-    if (typename_registry.contains(key))
-        return typename_registry.value(key);
-    else
-        return QString("SireUnits::Dimension::PhysUnit<%1,%2,%3,%4,%5,%6,%7>")
-                 .arg(unit.MASS()).arg(unit.LENGTH()).arg(unit.TIME())
-                 .arg(unit.CHARGE()).arg(unit.TEMPERATURE())
-                 .arg(unit.QUANTITY()).arg(unit.ANGLE());
-}
+        namespace detail
+        {
 
-} // end of namespace detail
-} // end of namespace Dimension
+            typedef QHash<QString, QString> TypenameRegistry;
+
+            Q_GLOBAL_STATIC(TypenameRegistry, typename_registry);
+            Q_GLOBAL_STATIC(QMutex, registry_mutex);
+
+            static QString getKey(const GeneralUnit &unit)
+            {
+                return QString("%1-%2-%3-%4-%5-%6-%7")
+                    .arg(unit.MASS())
+                    .arg(unit.LENGTH())
+                    .arg(unit.TIME())
+                    .arg(unit.CHARGE())
+                    .arg(unit.TEMPERATURE())
+                    .arg(unit.QUANTITY())
+                    .arg(unit.ANGLE());
+            }
+
+            void SIREUNITS_EXPORT registerTypeName(const GeneralUnit &unit, const char *typnam)
+            {
+                QString key = getKey(unit);
+
+                QMutexLocker lkr(registry_mutex());
+                if (not typename_registry()->contains(key))
+                {
+                    typename_registry()->insert(key, QString(typnam));
+                }
+            }
+
+            static QString getTypeName(const GeneralUnit &unit)
+            {
+                QString key = getKey(unit);
+
+                QMutexLocker lkr(registry_mutex());
+
+                if (typename_registry()->contains(key))
+                    return typename_registry()->value(key);
+                else
+                    return QString("SireUnits::Dimension::PhysUnit<%1,%2,%3,%4,%5,%6,%7>")
+                        .arg(unit.MASS())
+                        .arg(unit.LENGTH())
+                        .arg(unit.TIME())
+                        .arg(unit.CHARGE())
+                        .arg(unit.TEMPERATURE())
+                        .arg(unit.QUANTITY())
+                        .arg(unit.ANGLE());
+            }
+
+        } // end of namespace detail
+    }     // end of namespace Dimension
 } // end of namespace SireUnits
 
 GeneralUnit::GeneralUnit() : Unit(0)
@@ -153,7 +161,7 @@ GeneralUnit::GeneralUnit(const TempBase &t) : Unit(t)
 }
 
 GeneralUnit::GeneralUnit(const GeneralUnit &other)
-            : Unit(other), comps(other.comps)
+    : Unit(other), comps(other.comps)
 {
     Mass = other.Mass;
     Length = other.Length;
@@ -165,14 +173,15 @@ GeneralUnit::GeneralUnit(const GeneralUnit &other)
 }
 
 GeneralUnit::~GeneralUnit()
-{}
+{
+}
 
-const char* GeneralUnit::typeName()
+const char *GeneralUnit::typeName()
 {
-    return QMetaType::typeName( qMetaTypeId<GeneralUnit>() );
+    return QMetaType::typeName(qMetaTypeId<GeneralUnit>());
 }
 
-const char* GeneralUnit::what() const
+const char *GeneralUnit::what() const
 {
     return GeneralUnit::typeName();
 }
@@ -196,9 +205,10 @@ void GeneralUnit::assertCompatible(const GeneralUnit &other) const
         Quantity != other.Quantity or
         Angle != other.Angle)
     {
-        throw SireError::incompatible_error( QObject::tr(
-            "Units for values %1 and %2 are incompatible.")
-                .arg(this->toString()).arg(other.toString()));
+        throw SireError::incompatible_error(QObject::tr(
+                                                "Units for values %1 and %2 are incompatible.")
+                                                .arg(this->toString())
+                                                .arg(other.toString()));
     }
 }
 
@@ -207,7 +217,8 @@ QString GeneralUnit::unitString() const
     return SireUnits::Dimension::getUnitString(Mass, Length,
                                                Time, Charge,
                                                temperature, Quantity,
-                                               Angle).second;
+                                               Angle)
+        .second;
 }
 
 QString GeneralUnit::toString() const
@@ -236,7 +247,7 @@ double GeneralUnit::to(const GeneralUnit &units) const
 
 double GeneralUnit::to(const TempBase &other) const
 {
-    //this must be a temperature!
+    // this must be a temperature!
     GeneralUnit general_temp;
     general_temp.temperature = 1;
     general_temp.setScale(other);
@@ -321,7 +332,7 @@ bool GeneralUnit::hasSameUnits(const GeneralUnit &other) const
            Angle == other.Angle;
 }
 
-GeneralUnit& GeneralUnit::operator=(const GeneralUnit &other)
+GeneralUnit &GeneralUnit::operator=(const GeneralUnit &other)
 {
     setScale(other.value());
 
@@ -380,7 +391,7 @@ bool GeneralUnit::operator<=(const GeneralUnit &other) const
 GeneralUnit GeneralUnit::operator-() const
 {
     GeneralUnit ret = *this;
-    ret.setScale( -value() );
+    ret.setScale(-value());
 
     for (const auto &key : this->comps.keys())
     {
@@ -390,7 +401,47 @@ GeneralUnit GeneralUnit::operator-() const
     return ret;
 }
 
-GeneralUnit& GeneralUnit::operator+=(const GeneralUnit &other)
+GeneralUnit &GeneralUnit::operator+=(const TempBase &other)
+{
+    return this->operator+=(GeneralUnit(other));
+}
+
+GeneralUnit &GeneralUnit::operator-=(const TempBase &other)
+{
+    return this->operator-=(GeneralUnit(other));
+}
+
+GeneralUnit &GeneralUnit::operator*=(const TempBase &other)
+{
+    return this->operator*=(GeneralUnit(other));
+}
+
+GeneralUnit &GeneralUnit::operator/=(const TempBase &other)
+{
+    return this->operator/=(GeneralUnit(other));
+}
+
+GeneralUnit GeneralUnit::operator+(const TempBase &other) const
+{
+    return this->operator+(GeneralUnit(other));
+}
+
+GeneralUnit GeneralUnit::operator-(const TempBase &other) const
+{
+    return this->operator-(GeneralUnit(other));
+}
+
+GeneralUnit GeneralUnit::operator*(const TempBase &other) const
+{
+    return this->operator*(GeneralUnit(other));
+}
+
+GeneralUnit GeneralUnit::operator/(const TempBase &other) const
+{
+    return this->operator/(GeneralUnit(other));
+}
+
+GeneralUnit &GeneralUnit::operator+=(const GeneralUnit &other)
 {
     if (this->isZero())
     {
@@ -417,7 +468,7 @@ GeneralUnit& GeneralUnit::operator+=(const GeneralUnit &other)
     return *this;
 }
 
-GeneralUnit& GeneralUnit::operator-=(const GeneralUnit &other)
+GeneralUnit &GeneralUnit::operator-=(const GeneralUnit &other)
 {
     if (this->isZero())
     {
@@ -458,7 +509,7 @@ GeneralUnit GeneralUnit::operator-(const GeneralUnit &other) const
     return ret;
 }
 
-GeneralUnit& GeneralUnit::operator+=(double val)
+GeneralUnit &GeneralUnit::operator+=(double val)
 {
     assertCompatible(GeneralUnit(val));
     setScale(value() + val);
@@ -469,7 +520,7 @@ GeneralUnit& GeneralUnit::operator+=(double val)
     return *this;
 }
 
-GeneralUnit& GeneralUnit::operator-=(double val)
+GeneralUnit &GeneralUnit::operator-=(double val)
 {
     assertCompatible(GeneralUnit(val));
     setScale(value() - val);
@@ -494,7 +545,7 @@ GeneralUnit GeneralUnit::operator-(double val) const
     return ret;
 }
 
-GeneralUnit GeneralUnit::operator*=(const GeneralUnit &other)
+GeneralUnit &GeneralUnit::operator*=(const GeneralUnit &other)
 {
     setScale(value() * other.value());
     Mass += other.Mass;
@@ -543,7 +594,7 @@ GeneralUnit GeneralUnit::operator*=(const GeneralUnit &other)
     return *this;
 }
 
-GeneralUnit GeneralUnit::operator/=(const GeneralUnit &other)
+GeneralUnit &GeneralUnit::operator/=(const GeneralUnit &other)
 {
     setScale(value() / other.value());
     Mass -= other.Mass;
@@ -592,6 +643,46 @@ GeneralUnit GeneralUnit::operator/=(const GeneralUnit &other)
     return *this;
 }
 
+SIREUNITS_EXPORT GeneralUnit Celsius::operator+(const GeneralUnit &other) const
+{
+    return other.operator+(*this);
+}
+
+SIREUNITS_EXPORT GeneralUnit Celsius::operator-(const GeneralUnit &other) const
+{
+    return GeneralUnit(*this) - other;
+}
+
+SIREUNITS_EXPORT GeneralUnit Celsius::operator*(const GeneralUnit &other) const
+{
+    return other.operator*(*this);
+}
+
+SIREUNITS_EXPORT GeneralUnit Celsius::operator/(const GeneralUnit &other) const
+{
+    return GeneralUnit(*this) / other;
+}
+
+SIREUNITS_EXPORT GeneralUnit Fahrenheit::operator+(const GeneralUnit &other) const
+{
+    return other.operator+(*this);
+}
+
+SIREUNITS_EXPORT GeneralUnit Fahrenheit::operator-(const GeneralUnit &other) const
+{
+    return GeneralUnit(*this) - other;
+}
+
+SIREUNITS_EXPORT GeneralUnit Fahrenheit::operator*(const GeneralUnit &other) const
+{
+    return other.operator*(*this);
+}
+
+SIREUNITS_EXPORT GeneralUnit Fahrenheit::operator/(const GeneralUnit &other) const
+{
+    return GeneralUnit(*this) / other;
+}
+
 GeneralUnit GeneralUnit::operator*(const GeneralUnit &other) const
 {
     GeneralUnit ret = *this;
@@ -607,7 +698,7 @@ GeneralUnit GeneralUnit::operator/(const GeneralUnit &other) const
     return ret;
 }
 
-GeneralUnit& GeneralUnit::operator*=(double val)
+GeneralUnit &GeneralUnit::operator*=(double val)
 {
     setScale(value() * val);
 
@@ -625,7 +716,7 @@ GeneralUnit& GeneralUnit::operator*=(double val)
     return *this;
 }
 
-GeneralUnit& GeneralUnit::operator/=(double val)
+GeneralUnit &GeneralUnit::operator/=(double val)
 {
     setScale(value() / val);
 
@@ -643,12 +734,12 @@ GeneralUnit& GeneralUnit::operator/=(double val)
     return *this;
 }
 
-GeneralUnit& GeneralUnit::operator*=(int val)
+GeneralUnit &GeneralUnit::operator*=(int val)
 {
     return this->operator*=(double(val));
 }
 
-GeneralUnit& GeneralUnit::operator/=(int val)
+GeneralUnit &GeneralUnit::operator/=(int val)
 {
     return this->operator/=(double(val));
 }
@@ -685,7 +776,7 @@ GeneralUnit GeneralUnit::invert() const
 {
     GeneralUnit ret;
 
-    ret.setScale( 1.0 / value() );
+    ret.setScale(1.0 / value());
 
     ret.Mass = -Mass;
     ret.Length = -Length;
@@ -701,15 +792,15 @@ GeneralUnit GeneralUnit::invert() const
     return ret;
 }
 
-QHash<QString,GeneralUnit> GeneralUnit::components() const
+QHash<QString, GeneralUnit> GeneralUnit::components() const
 {
-    QHash<QString,GeneralUnit> c;
+    QHash<QString, GeneralUnit> c;
     c.reserve(this->comps.count());
 
     for (const auto &key : this->comps.keys())
     {
         GeneralUnit v(*this);
-        v.comps = QHash<QString,double>();
+        v.comps = QHash<QString, double>();
         v.setScale(this->comps[key]);
         c.insert(key, v);
     }
@@ -720,7 +811,7 @@ QHash<QString,GeneralUnit> GeneralUnit::components() const
 GeneralUnit GeneralUnit::getComponent(const QString &component) const
 {
     GeneralUnit v(*this);
-    v.comps = QHash<QString,double>();
+    v.comps = QHash<QString, double>();
     v.setScale(this->comps.value(component));
     return v;
 }
diff --git a/corelib/src/libs/SireUnits/generalunit.h b/corelib/src/libs/SireUnits/generalunit.h
index d076b157f..d9384db94 100644
--- a/corelib/src/libs/SireUnits/generalunit.h
+++ b/corelib/src/libs/SireUnits/generalunit.h
@@ -8,261 +8,274 @@
 
 SIRE_BEGIN_HEADER
 
-namespace SireUnits{ namespace Dimension {
-class GeneralUnit;
-}}
-
-SIREUNITS_EXPORT QDataStream& operator<<(QDataStream&, const SireUnits::Dimension::GeneralUnit&);
-SIREUNITS_EXPORT QDataStream& operator>>(QDataStream&, SireUnits::Dimension::GeneralUnit&);
-
 namespace SireUnits
 {
-
-namespace Dimension
-{
-
-class GeneralUnit;
-class TempBase;
-class _Pvt_Kelvin;
-
-namespace detail
-{
-void SIREUNITS_EXPORT registerTypeName(const GeneralUnit &unit, const char *typnam);
+    namespace Dimension
+    {
+        class GeneralUnit;
+    }
 }
 
-class SIREUNITS_EXPORT GeneralUnit : public Unit
-{
-
-friend QDataStream& ::operator<<(QDataStream&, const GeneralUnit&);
-friend QDataStream& ::operator>>(QDataStream&, GeneralUnit&);
-
-public:
-    GeneralUnit();
-
-    explicit GeneralUnit(const TempBase &temperature);
+SIREUNITS_EXPORT QDataStream &operator<<(QDataStream &, const SireUnits::Dimension::GeneralUnit &);
+SIREUNITS_EXPORT QDataStream &operator>>(QDataStream &, SireUnits::Dimension::GeneralUnit &);
 
-    explicit GeneralUnit(double value);
+namespace SireUnits
+{
 
-    template<int M, int L, int T,
-             int C, int t, int Q, int A>
-    explicit GeneralUnit(const PhysUnit<M,L,T,C,t,Q,A> &unit) : Unit(unit)
+    namespace Dimension
     {
-        Mass = M;
-        Length = L;
-        Time = T;
-        Charge = C;
-        temperature = t;
-        Quantity = Q;
-        Angle = A;
-        detail::registerTypeName(*this, PhysUnit<M,L,T,C,t,Q,A>::typeName());
-
-        if (this->isZero())
-            this->operator=(GeneralUnit());
-    }
 
-    GeneralUnit(const GeneralUnit &other);
+        class GeneralUnit;
+        class TempBase;
+        class _Pvt_Kelvin;
 
-    ~GeneralUnit();
+        namespace detail
+        {
+            void SIREUNITS_EXPORT registerTypeName(const GeneralUnit &unit, const char *typnam);
+        }
 
-    static const char* typeName();
-    const char* what() const;
+        class SIREUNITS_EXPORT GeneralUnit : public Unit
+        {
 
-    QString _to_cpp_type() const;
+            friend QDataStream & ::operator<<(QDataStream &, const GeneralUnit &);
+            friend QDataStream & ::operator>>(QDataStream &, GeneralUnit &);
 
-    QString unitString() const;
+        public:
+            GeneralUnit();
 
-    GeneralUnit units() const;
+            explicit GeneralUnit(const TempBase &temperature);
 
-    int MASS() const;
-    int LENGTH() const;
-    int TIME() const;
-    int CHARGE() const;
-    int TEMPERATURE() const;
-    int QUANTITY() const;
-    int ANGLE() const;
+            explicit GeneralUnit(double value);
 
-    bool hasSameUnits(const GeneralUnit &other) const;
+            template <int M, int L, int T,
+                      int C, int t, int Q, int A>
+            explicit GeneralUnit(const PhysUnit<M, L, T, C, t, Q, A> &unit) : Unit(unit)
+            {
+                Mass = M;
+                Length = L;
+                Time = T;
+                Charge = C;
+                temperature = t;
+                Quantity = Q;
+                Angle = A;
+                detail::registerTypeName(*this, PhysUnit<M, L, T, C, t, Q, A>::typeName());
 
-    GeneralUnit& operator=(const GeneralUnit &other);
+                if (this->isZero())
+                    this->operator=(GeneralUnit());
+            }
 
-    bool operator==(const GeneralUnit &other) const;
-    bool operator!=(const GeneralUnit &other) const;
+            GeneralUnit(const GeneralUnit &other);
 
-    bool operator>(const GeneralUnit &other) const;
-    bool operator>=(const GeneralUnit &other) const;
-    bool operator<(const GeneralUnit &other) const;
-    bool operator<=(const GeneralUnit &other) const;
+            ~GeneralUnit();
 
-    GeneralUnit operator-() const;
+            static const char *typeName();
+            const char *what() const;
 
-    GeneralUnit& operator+=(const GeneralUnit &other);
+            QString _to_cpp_type() const;
 
-    GeneralUnit& operator-=(const GeneralUnit &other);
+            QString unitString() const;
 
-    GeneralUnit operator+(const GeneralUnit &other) const;
+            GeneralUnit units() const;
 
-    GeneralUnit operator-(const GeneralUnit &other) const;
+            int MASS() const;
+            int LENGTH() const;
+            int TIME() const;
+            int CHARGE() const;
+            int TEMPERATURE() const;
+            int QUANTITY() const;
+            int ANGLE() const;
 
-    GeneralUnit operator*=(const GeneralUnit &other);
+            bool hasSameUnits(const GeneralUnit &other) const;
 
-    GeneralUnit operator/=(const GeneralUnit &other);
+            GeneralUnit &operator=(const GeneralUnit &other);
 
-    GeneralUnit operator*(const GeneralUnit &other) const;
+            bool operator==(const GeneralUnit &other) const;
+            bool operator!=(const GeneralUnit &other) const;
 
-    GeneralUnit operator/(const GeneralUnit &other) const;
+            bool operator>(const GeneralUnit &other) const;
+            bool operator>=(const GeneralUnit &other) const;
+            bool operator<(const GeneralUnit &other) const;
+            bool operator<=(const GeneralUnit &other) const;
 
-    GeneralUnit& operator+=(double val);
-    GeneralUnit& operator-=(double val);
+            GeneralUnit operator-() const;
 
-    GeneralUnit operator+(double val) const;
-    GeneralUnit operator-(double val) const;
+            GeneralUnit &operator+=(const GeneralUnit &other);
+            GeneralUnit &operator+=(const TempBase &other);
 
-    GeneralUnit& operator*=(double val);
-    GeneralUnit& operator/=(double val);
+            GeneralUnit &operator-=(const GeneralUnit &other);
+            GeneralUnit &operator-=(const TempBase &other);
 
-    GeneralUnit& operator*=(int val);
-    GeneralUnit& operator/=(int val);
+            GeneralUnit operator+(const GeneralUnit &other) const;
+            GeneralUnit operator+(const TempBase &other) const;
 
-    GeneralUnit operator*(double val) const;
-    GeneralUnit operator/(double val) const;
+            GeneralUnit operator-(const GeneralUnit &other) const;
+            GeneralUnit operator-(const TempBase &other) const;
 
-    GeneralUnit operator*(int val) const;
-    GeneralUnit operator/(int val) const;
+            GeneralUnit &operator*=(const GeneralUnit &other);
+            GeneralUnit &operator*=(const TempBase &other);
 
-    GeneralUnit invert() const;
+            GeneralUnit &operator/=(const GeneralUnit &other);
+            GeneralUnit &operator/=(const TempBase &other);
 
-    double to(const TempBase &other) const;
-    double to(const GeneralUnit &other) const;
+            GeneralUnit operator*(const GeneralUnit &other) const;
+            GeneralUnit operator*(const TempBase &other) const;
 
-    QString toString() const;
+            GeneralUnit operator/(const GeneralUnit &other) const;
+            GeneralUnit operator/(const TempBase &other) const;
 
-    template<class T>
-    bool isUnit() const;
+            GeneralUnit &operator+=(double val);
+            GeneralUnit &operator-=(double val);
 
-    template<class T>
-    T toUnit() const;
+            GeneralUnit operator+(double val) const;
+            GeneralUnit operator-(double val) const;
 
-    bool isDimensionless() const;
+            GeneralUnit &operator*=(double val);
+            GeneralUnit &operator/=(double val);
 
-    bool isZero() const;
+            GeneralUnit &operator*=(int val);
+            GeneralUnit &operator/=(int val);
 
-    void setAsDefault(const QString &unit_name) const;
+            GeneralUnit operator*(double val) const;
+            GeneralUnit operator/(double val) const;
 
-    GeneralUnit getDefault() const;
+            GeneralUnit operator*(int val) const;
+            GeneralUnit operator/(int val) const;
 
-    QHash<QString,GeneralUnit> components() const;
+            GeneralUnit invert() const;
 
-    GeneralUnit getComponent(const QString &component) const;
+            double to(const TempBase &other) const;
+            double to(const GeneralUnit &other) const;
 
-    void setComponent(const QString &component,
-                      const GeneralUnit &value);
+            QString toString() const;
 
-    void addComponent(const QString &component,
-                      const GeneralUnit &value);
+            template <class T>
+            bool isUnit() const;
 
-    void subtractComponent(const QString &component,
-                           const GeneralUnit &value);
+            template <class T>
+            T toUnit() const;
 
-    template<int M, int L, int T,
-             int C, int t, int Q, int A>
-    void setComponent(const QString &component,
-                      const PhysUnit<M,L,T,C,t,Q,A> &value)
-    {
-        this->setComponent(component, GeneralUnit(value));
-    }
+            bool isDimensionless() const;
 
-    template<int M, int L, int T,
-             int C, int t, int Q, int A>
-    void addComponent(const QString &component,
-                      const PhysUnit<M,L,T,C,t,Q,A> &value)
-    {
-        this->addComponent(component, GeneralUnit(value));
-    }
+            bool isZero() const;
 
-    template<int M, int L, int T,
-             int C, int t, int Q, int A>
-    void subtractComponent(const QString &component,
-                      const PhysUnit<M,L,T,C,t,Q,A> &value)
-    {
-        this->subtractComponent(component, GeneralUnit(value));
-    }
+            void setAsDefault(const QString &unit_name) const;
 
-private:
-    void assertCompatible(const GeneralUnit &other) const;
+            GeneralUnit getDefault() const;
 
-    int Mass, Length, Time, Charge, temperature, Quantity, Angle;
+            QHash<QString, GeneralUnit> components() const;
 
-    QHash<QString,double> comps;
-};
+            GeneralUnit getComponent(const QString &component) const;
 
-#ifndef SIRE_SKIP_INLINE_FUNCTIONS
+            void setComponent(const QString &component,
+                              const GeneralUnit &value);
 
-template<class T>
-inline bool GeneralUnit::isUnit() const
-{
-    return this->MASS() == T::MASS() and
-           this->LENGTH() == T::LENGTH() and
-           this->TIME() == T::TIME() and
-           this->CHARGE() == T::CHARGE() and
-           this->TEMPERATURE() == T::TEMPERATURE() and
-           this->QUANTITY() == T::QUANTITY() and
-           this->ANGLE() == T::ANGLE();
-}
+            void addComponent(const QString &component,
+                              const GeneralUnit &value);
 
-template<class T>
-inline T GeneralUnit::toUnit() const
-{
-    this->assertCompatible(GeneralUnit(T(1.0)));
-    return this->scaleFactor() * T(1.0);
-}
+            void subtractComponent(const QString &component,
+                                   const GeneralUnit &value);
 
-inline GeneralUnit operator*(double val, const GeneralUnit &unit)
-{
-    return unit * val;
-}
+            template <int M, int L, int T,
+                      int C, int t, int Q, int A>
+            void setComponent(const QString &component,
+                              const PhysUnit<M, L, T, C, t, Q, A> &value)
+            {
+                this->setComponent(component, GeneralUnit(value));
+            }
 
-inline GeneralUnit operator*(int val, const GeneralUnit &unit)
-{
-    return unit * val;
-}
+            template <int M, int L, int T,
+                      int C, int t, int Q, int A>
+            void addComponent(const QString &component,
+                              const PhysUnit<M, L, T, C, t, Q, A> &value)
+            {
+                this->addComponent(component, GeneralUnit(value));
+            }
 
-inline GeneralUnit operator/(double val, const GeneralUnit &unit)
-{
-    return unit.invert() * val;
-}
+            template <int M, int L, int T,
+                      int C, int t, int Q, int A>
+            void subtractComponent(const QString &component,
+                                   const PhysUnit<M, L, T, C, t, Q, A> &value)
+            {
+                this->subtractComponent(component, GeneralUnit(value));
+            }
 
-inline GeneralUnit operator/(int val, const GeneralUnit &unit)
-{
-    return unit.invert() * val;
-}
+        private:
+            void assertCompatible(const GeneralUnit &other) const;
 
-template<int M, int L, int T,
-         int C, int t, int Q, int A>
-SIRE_OUTOFLINE_TEMPLATE
-PhysUnit<M,L,T,C,t,Q,A>& PhysUnit<M,L,T,C,t,Q,A>::operator=(const GeneralUnit &other)
-{
-    this->operator=(other.toUnit<PhysUnit<M,L,T,C,t,Q,A>>());
-    return *this;
-}
+            int Mass, Length, Time, Charge, temperature, Quantity, Angle;
 
-template<int M, int L, int T,
-         int C, int t, int Q, int A>
-SIRE_OUTOFLINE_TEMPLATE
-PhysUnit<M,L,T,C,t,Q,A>::PhysUnit(const GeneralUnit &other)
-                        : Unit(0)
-{
-    this->operator=(other);
-}
+            QHash<QString, double> comps;
+        };
 
-#endif //SIRE_SKIP_INLINE_FUNCTIONS
+#ifndef SIRE_SKIP_INLINE_FUNCTIONS
 
-} // end of namespace Dimension
+        template <class T>
+        inline bool GeneralUnit::isUnit() const
+        {
+            return this->MASS() == T::MASS() and
+                   this->LENGTH() == T::LENGTH() and
+                   this->TIME() == T::TIME() and
+                   this->CHARGE() == T::CHARGE() and
+                   this->TEMPERATURE() == T::TEMPERATURE() and
+                   this->QUANTITY() == T::QUANTITY() and
+                   this->ANGLE() == T::ANGLE();
+        }
+
+        template <class T>
+        inline T GeneralUnit::toUnit() const
+        {
+            this->assertCompatible(GeneralUnit(T(1.0)));
+            return this->scaleFactor() * T(1.0);
+        }
+
+        inline GeneralUnit operator*(double val, const GeneralUnit &unit)
+        {
+            return unit * val;
+        }
+
+        inline GeneralUnit operator*(int val, const GeneralUnit &unit)
+        {
+            return unit * val;
+        }
+
+        inline GeneralUnit operator/(double val, const GeneralUnit &unit)
+        {
+            return unit.invert() * val;
+        }
+
+        inline GeneralUnit operator/(int val, const GeneralUnit &unit)
+        {
+            return unit.invert() * val;
+        }
+
+        template <int M, int L, int T,
+                  int C, int t, int Q, int A>
+        SIRE_OUTOFLINE_TEMPLATE
+            PhysUnit<M, L, T, C, t, Q, A> &
+            PhysUnit<M, L, T, C, t, Q, A>::operator=(const GeneralUnit &other)
+        {
+            this->operator=(other.toUnit<PhysUnit<M, L, T, C, t, Q, A>>());
+            return *this;
+        }
+
+        template <int M, int L, int T,
+                  int C, int t, int Q, int A>
+        SIRE_OUTOFLINE_TEMPLATE
+        PhysUnit<M, L, T, C, t, Q, A>::PhysUnit(const GeneralUnit &other)
+            : Unit(0)
+        {
+            this->operator=(other);
+        }
+
+#endif // SIRE_SKIP_INLINE_FUNCTIONS
+
+    } // end of namespace Dimension
 
 }
 
-Q_DECLARE_METATYPE( SireUnits::Dimension::GeneralUnit );
+Q_DECLARE_METATYPE(SireUnits::Dimension::GeneralUnit);
 
-SIRE_EXPOSE_CLASS( SireUnits::Dimension::GeneralUnit )
+SIRE_EXPOSE_CLASS(SireUnits::Dimension::GeneralUnit)
 
 SIRE_END_HEADER
 
diff --git a/corelib/src/libs/SireUnits/temperature.h b/corelib/src/libs/SireUnits/temperature.h
index e95b0300f..2e9f8ac02 100644
--- a/corelib/src/libs/SireUnits/temperature.h
+++ b/corelib/src/libs/SireUnits/temperature.h
@@ -35,444 +35,471 @@ SIRE_BEGIN_HEADER
 namespace SireUnits
 {
 
-class Celsius;
-class Fahrenheit;
+    class Celsius;
+    class Fahrenheit;
 
-namespace Dimension
-{
-
-//skip this completely when parsing with gccxml as it is broken!
-#ifdef SKIP_BROKEN_GCCXML_PARTS
-
-class Temperature
-{
-public:
-    Temperature();
-    Temperature(double);
-    ~Temperature();
-
-    operator double() const;
-};
-
-#endif // end of 'ifdef SKIP_BROKEN_GCCXML_PARTS'
-
-class TempBase
-{
-friend class SireUnits::Celsius;
-friend class SireUnits::Fahrenheit;
-
-public:
-    TempBase(double value = 0) : val(value)
-    {}
-
-    TempBase(const TempBase &other) : val(other.val)
-    {}
-
-    TempBase(const Temperature &temp) : val(temp)
-    {}
-
-    virtual ~TempBase()
-    {}
-
-    TempBase& operator=(const TempBase &other)
-    {
-        val = other.val;
-        return *this;
-    }
-
-    TempBase& operator=(const Temperature &temp)
-    {
-        val = double(temp);
-        return *this;
-    }
-
-    bool operator==(const TempBase &other) const
-    {
-        return val == other.val;
-    }
-
-    bool operator!=(const TempBase &other) const
-    {
-        return val != other.val;
-    }
-
-    bool operator==(const Temperature &temp) const
+    namespace Dimension
     {
-        return val == double(temp);
-    }
 
-    bool operator!=(const Temperature &temp) const
-    {
-        return val != double(temp);
-    }
-
-    double value() const
-    {
-        return val;
-    }
-
-    QString toString() const
-    {
-        return QString("%1°%2").arg(this->convertFromInternal()).arg(this->unitString());
-    }
-
-    /** Convert this into a temperature object */
-    operator Temperature() const
-    {
-        return Temperature(val);
-    }
-
-    operator double() const
-    {
-        return val;
-    }
-
-    double in(const TempBase &other) const
-    {
-        return other.convertFromInternal(val) / other.convertFromInternal();
-    }
-
-    double in(const Temperature &temp) const
-    {
-        return val * temp;
-    }
-
-    double to(const TempBase &other) const
-    {
-        return this->in(other);
-    }
+        class GeneralUnit;
 
-    virtual double convertToInternal(double value) const=0;
-    virtual double convertFromInternal(double value) const=0;
+// skip this completely when parsing with gccxml as it is broken!
+#ifdef SKIP_BROKEN_GCCXML_PARTS
 
-    double convertFromInternal() const
-    {
-        return this->convertFromInternal(val);
-    }
+        class Temperature
+        {
+        public:
+            Temperature();
+            Temperature(double);
+            ~Temperature();
 
-protected:
-    virtual QString unitString() const
-    {
-        return "K";
-    }
+            operator double() const;
+        };
 
-    /** This holds the temperature in internal units (K) */
-    double val;
-};
+#endif // end of 'ifdef SKIP_BROKEN_GCCXML_PARTS'
 
-/** Construct a Unit from a TempBase */
-SIRE_ALWAYS_INLINE Unit::Unit(const TempBase &temperature)
+        class TempBase
+        {
+            friend class SireUnits::Celsius;
+            friend class SireUnits::Fahrenheit;
+
+        public:
+            TempBase(double value = 0) : val(value)
+            {
+            }
+
+            TempBase(const TempBase &other) : val(other.val)
+            {
+            }
+
+            TempBase(const Temperature &temp) : val(temp)
+            {
+            }
+
+            virtual ~TempBase()
+            {
+            }
+
+            TempBase &operator=(const TempBase &other)
+            {
+                val = other.val;
+                return *this;
+            }
+
+            TempBase &operator=(const Temperature &temp)
+            {
+                val = double(temp);
+                return *this;
+            }
+
+            bool operator==(const TempBase &other) const
+            {
+                return val == other.val;
+            }
+
+            bool operator!=(const TempBase &other) const
+            {
+                return val != other.val;
+            }
+
+            bool operator==(const Temperature &temp) const
+            {
+                return val == double(temp);
+            }
+
+            bool operator!=(const Temperature &temp) const
+            {
+                return val != double(temp);
+            }
+
+            double value() const
+            {
+                return val;
+            }
+
+            QString toString() const
+            {
+                return QString("%1°%2").arg(this->convertFromInternal()).arg(this->unitString());
+            }
+
+            /** Convert this into a temperature object */
+            operator Temperature() const
+            {
+                return Temperature(val);
+            }
+
+            operator double() const
+            {
+                return val;
+            }
+
+            double in(const TempBase &other) const
+            {
+                return other.convertFromInternal(val) / other.convertFromInternal();
+            }
+
+            double in(const Temperature &temp) const
+            {
+                return val * temp;
+            }
+
+            double to(const TempBase &other) const
+            {
+                return this->in(other);
+            }
+
+            virtual double convertToInternal(double value) const = 0;
+            virtual double convertFromInternal(double value) const = 0;
+
+            double convertFromInternal() const
+            {
+                return this->convertFromInternal(val);
+            }
+
+        protected:
+            virtual QString unitString() const
+            {
+                return "K";
+            }
+
+            /** This holds the temperature in internal units (K) */
+            double val;
+        };
+
+        /** Construct a Unit from a TempBase */
+        SIRE_ALWAYS_INLINE Unit::Unit(const TempBase &temperature)
             : sclfac(temperature)
-{}
-
-} //end of namespace Dimension
-
-class Celsius : public Dimension::TempBase
-{
-
-public:
-    Celsius() : Dimension::TempBase(1)
-    {}
-
-    explicit Celsius(double value) : Dimension::TempBase()
-    {
-        val = convertToInternal(value);
-    }
-
-    Celsius(const Dimension::Temperature &temp) : Dimension::TempBase(temp)
-    {}
-
-    Celsius(const Dimension::TempBase &other) : Dimension::TempBase(other)
-    {}
-
-    Celsius(const Celsius &other)
-          : Dimension::TempBase(other)
-    {}
-
-    ~Celsius()
-    {}
-
-    double convertToInternal(double value) const
-    {
-        return value + 273.15;
-    }
-
-    double convertFromInternal(double value) const
-    {
-        return value - 273.15;
-    }
-
-    double convertFromInternal() const
-    {
-        return Dimension::TempBase::convertFromInternal();
-    }
-
-    Celsius& operator=(const Celsius &other)
-    {
-        Dimension::TempBase::operator=(other);
-        return *this;
-    }
-
-    Celsius& operator=(const Dimension::Temperature &temp)
-    {
-        Dimension::TempBase::operator=(temp);
-        return *this;
-    }
-
-    Celsius operator-() const
-    {
-        return Celsius(-convertFromInternal());
-    }
-
-    Celsius operator+(const Celsius &other) const
-    {
-        return Celsius(convertFromInternal() + other.convertFromInternal());
-    }
-
-    Celsius operator-(const Celsius &other) const
-    {
-        return Celsius(convertFromInternal() - other.convertFromInternal());
-    }
-
-    Celsius& operator+=(const Celsius &other)
-    {
-        convertToInternal( convertFromInternal() + other.convertFromInternal() );
-        return *this;
-    }
-
-    Celsius& operator-=(const Celsius &other)
-    {
-        convertToInternal( convertFromInternal() - other.convertFromInternal() );
-        return *this;
-    }
-
-    Celsius operator+(const Dimension::Temperature &other) const
-    {
-        return *this + Celsius(other);
+        {
+        }
+
+    } // end of namespace Dimension
+
+    class Celsius : public Dimension::TempBase
+    {
+
+    public:
+        Celsius() : Dimension::TempBase(1)
+        {
+        }
+
+        explicit Celsius(double value) : Dimension::TempBase()
+        {
+            val = convertToInternal(value);
+        }
+
+        Celsius(const Dimension::Temperature &temp) : Dimension::TempBase(temp)
+        {
+        }
+
+        Celsius(const Dimension::TempBase &other) : Dimension::TempBase(other)
+        {
+        }
+
+        Celsius(const Celsius &other)
+            : Dimension::TempBase(other)
+        {
+        }
+
+        ~Celsius()
+        {
+        }
+
+        double convertToInternal(double value) const
+        {
+            return value + 273.15;
+        }
+
+        double convertFromInternal(double value) const
+        {
+            return value - 273.15;
+        }
+
+        double convertFromInternal() const
+        {
+            return Dimension::TempBase::convertFromInternal();
+        }
+
+        Celsius &operator=(const Celsius &other)
+        {
+            Dimension::TempBase::operator=(other);
+            return *this;
+        }
+
+        Celsius &operator=(const Dimension::Temperature &temp)
+        {
+            Dimension::TempBase::operator=(temp);
+            return *this;
+        }
+
+        Celsius operator-() const
+        {
+            return Celsius(-convertFromInternal());
+        }
+
+        Celsius operator+(const Celsius &other) const
+        {
+            return Celsius(convertFromInternal() + other.convertFromInternal());
+        }
+
+        Celsius operator-(const Celsius &other) const
+        {
+            return Celsius(convertFromInternal() - other.convertFromInternal());
+        }
+
+        Celsius &operator+=(const Celsius &other)
+        {
+            convertToInternal(convertFromInternal() + other.convertFromInternal());
+            return *this;
+        }
+
+        Celsius &operator-=(const Celsius &other)
+        {
+            convertToInternal(convertFromInternal() - other.convertFromInternal());
+            return *this;
+        }
+
+        Celsius operator+(const Dimension::Temperature &other) const
+        {
+            return *this + Celsius(other);
+        }
+
+        Celsius operator-(const Dimension::Temperature &other) const
+        {
+            return *this - Celsius(other);
+        }
+
+        Celsius &operator+=(const Dimension::Temperature &other)
+        {
+            return this->operator+=(Celsius(other));
+        }
+
+        Celsius &operator-=(const Dimension::Temperature &other)
+        {
+            return this->operator-=(Celsius(other));
+        }
+
+        Celsius operator*(double value) const
+        {
+            return Celsius(value * convertFromInternal());
+        }
+
+        Celsius operator/(double value) const
+        {
+            return Celsius(value / convertFromInternal());
+        }
+
+        Celsius operator*(int value) const
+        {
+            return Celsius(value * convertFromInternal());
+        }
+
+        Celsius operator/(int value) const
+        {
+            return Celsius(value / convertFromInternal());
+        }
+
+        SIREUNITS_EXPORT Dimension::GeneralUnit operator+(const Dimension::GeneralUnit &other) const;
+        SIREUNITS_EXPORT Dimension::GeneralUnit operator-(const Dimension::GeneralUnit &other) const;
+        SIREUNITS_EXPORT Dimension::GeneralUnit operator*(const Dimension::GeneralUnit &other) const;
+        SIREUNITS_EXPORT Dimension::GeneralUnit operator/(const Dimension::GeneralUnit &other) const;
+
+    protected:
+        QString unitString() const
+        {
+            return "C";
+        }
+    };
+
+    SIRE_ALWAYS_INLINE Celsius operator*(double value, const Celsius &temp)
+    {
+        return temp * value;
     }
 
-    Celsius operator-(const Dimension::Temperature &other) const
-    {
-        return *this - Celsius(other);
-    }
-
-    Celsius& operator+=(const Dimension::Temperature &other)
-    {
-        return this->operator+=(Celsius(other));
-    }
-
-    Celsius& operator-=(const Dimension::Temperature &other)
-    {
-        return this->operator-=(Celsius(other));
-    }
-
-    Celsius operator*(double value) const
-    {
-        return Celsius(value * convertFromInternal());
-    }
-
-    Celsius operator/(double value) const
-    {
-        return Celsius(value / convertFromInternal());
-    }
-
-    Celsius operator*(int value) const
-    {
-        return Celsius(value * convertFromInternal());
-    }
-
-    Celsius operator/(int value) const
-    {
-        return Celsius(value / convertFromInternal());
-    }
-
-protected:
-    QString unitString() const
-    {
-        return "C";
-    }
-};
-
-SIRE_ALWAYS_INLINE Celsius operator*(double value, const Celsius &temp)
-{
-    return temp * value;
-}
-
 #ifndef SKIP_BROKEN_GCCXML_PARTS
-SIRE_ALWAYS_INLINE Dimension::PhysUnit<0,0,0,0,-1,0,0> operator/(double value, const Celsius &temp)
-{
-    return Dimension::PhysUnit<0,0,0,0,-1,0,0>(value / temp.convertFromInternal());
-}
-
-SIRE_ALWAYS_INLINE Dimension::PhysUnit<0,0,0,0,-1,0,0> operator/(int value, const Celsius &temp)
-{
-    return Dimension::PhysUnit<0,0,0,0,-1,0,0>(value / temp.convertFromInternal());
-}
-#endif
-
-SIRE_ALWAYS_INLINE Celsius operator*(int value, const Celsius &temp)
-{
-    return temp * value;
-}
-
-class Fahrenheit : public Dimension::TempBase
-{
-
-public:
-    Fahrenheit() : Dimension::TempBase(1)
-    {}
-
-    explicit Fahrenheit(double value) : Dimension::TempBase()
-    {
-        val = convertToInternal(value);
-    }
-
-    Fahrenheit(const Dimension::Temperature &temp) : Dimension::TempBase(temp)
-    {}
-
-    Fahrenheit(const Dimension::TempBase &other) : Dimension::TempBase(other)
-    {}
-
-    Fahrenheit(const Fahrenheit &other)
-          : Dimension::TempBase(other)
-    {}
-
-    ~Fahrenheit()
-    {}
-
-    double convertToInternal(double value) const
-    {
-        return (value + 459.67) / 1.8;
-    }
-
-    double convertFromInternal(double value) const
+    SIRE_ALWAYS_INLINE Dimension::PhysUnit<0, 0, 0, 0, -1, 0, 0> operator/(double value, const Celsius &temp)
     {
-        return (value * 1.8) - 459.67;
+        return Dimension::PhysUnit<0, 0, 0, 0, -1, 0, 0>(value / temp.convertFromInternal());
     }
 
-    double convertFromInternal() const
+    SIRE_ALWAYS_INLINE Dimension::PhysUnit<0, 0, 0, 0, -1, 0, 0> operator/(int value, const Celsius &temp)
     {
-        return Dimension::TempBase::convertFromInternal();
-    }
-
-    Fahrenheit& operator=(const Fahrenheit &other)
-    {
-        Dimension::TempBase::operator=(other);
-        return *this;
-    }
-
-    Fahrenheit& operator=(const Dimension::Temperature &temp)
-    {
-        Dimension::TempBase::operator=(temp);
-        return *this;
-    }
-
-    Fahrenheit operator-() const
-    {
-        return Fahrenheit(-convertFromInternal());
-    }
-
-    Fahrenheit operator+(const Fahrenheit &other) const
-    {
-        return Fahrenheit(convertFromInternal() + other.convertFromInternal());
-    }
-
-    Fahrenheit operator-(const Fahrenheit &other) const
-    {
-        return Fahrenheit(convertFromInternal() - other.convertFromInternal());
-    }
-
-    Fahrenheit& operator+=(const Fahrenheit &other)
-    {
-        convertToInternal( convertFromInternal() + other.convertFromInternal() );
-        return *this;
-    }
-
-    Fahrenheit& operator-=(const Fahrenheit &other)
-    {
-        convertToInternal( convertFromInternal() - other.convertFromInternal() );
-        return *this;
-    }
-
-    Fahrenheit operator+(const Dimension::Temperature &other) const
-    {
-        return *this + Fahrenheit(other);
-    }
-
-    Fahrenheit operator-(const Dimension::Temperature &other) const
-    {
-        return *this - Fahrenheit(other);
+        return Dimension::PhysUnit<0, 0, 0, 0, -1, 0, 0>(value / temp.convertFromInternal());
     }
+#endif
 
-    Fahrenheit& operator+=(const Dimension::Temperature &other)
-    {
-        return this->operator+=(Fahrenheit(other));
-    }
+    SIRE_ALWAYS_INLINE Celsius operator*(int value, const Celsius &temp)
+    {
+        return temp * value;
+    }
+
+    class Fahrenheit : public Dimension::TempBase
+    {
+
+    public:
+        Fahrenheit() : Dimension::TempBase(1)
+        {
+        }
+
+        explicit Fahrenheit(double value) : Dimension::TempBase()
+        {
+            val = convertToInternal(value);
+        }
+
+        Fahrenheit(const Dimension::Temperature &temp) : Dimension::TempBase(temp)
+        {
+        }
+
+        Fahrenheit(const Dimension::TempBase &other) : Dimension::TempBase(other)
+        {
+        }
+
+        Fahrenheit(const Fahrenheit &other)
+            : Dimension::TempBase(other)
+        {
+        }
+
+        ~Fahrenheit()
+        {
+        }
+
+        double convertToInternal(double value) const
+        {
+            return (value + 459.67) / 1.8;
+        }
+
+        double convertFromInternal(double value) const
+        {
+            return (value * 1.8) - 459.67;
+        }
+
+        double convertFromInternal() const
+        {
+            return Dimension::TempBase::convertFromInternal();
+        }
+
+        Fahrenheit &operator=(const Fahrenheit &other)
+        {
+            Dimension::TempBase::operator=(other);
+            return *this;
+        }
+
+        Fahrenheit &operator=(const Dimension::Temperature &temp)
+        {
+            Dimension::TempBase::operator=(temp);
+            return *this;
+        }
+
+        Fahrenheit operator-() const
+        {
+            return Fahrenheit(-convertFromInternal());
+        }
+
+        Fahrenheit operator+(const Fahrenheit &other) const
+        {
+            return Fahrenheit(convertFromInternal() + other.convertFromInternal());
+        }
+
+        Fahrenheit operator-(const Fahrenheit &other) const
+        {
+            return Fahrenheit(convertFromInternal() - other.convertFromInternal());
+        }
+
+        Fahrenheit &operator+=(const Fahrenheit &other)
+        {
+            convertToInternal(convertFromInternal() + other.convertFromInternal());
+            return *this;
+        }
+
+        Fahrenheit &operator-=(const Fahrenheit &other)
+        {
+            convertToInternal(convertFromInternal() - other.convertFromInternal());
+            return *this;
+        }
+
+        Fahrenheit operator+(const Dimension::Temperature &other) const
+        {
+            return *this + Fahrenheit(other);
+        }
+
+        Fahrenheit operator-(const Dimension::Temperature &other) const
+        {
+            return *this - Fahrenheit(other);
+        }
+
+        Fahrenheit &operator+=(const Dimension::Temperature &other)
+        {
+            return this->operator+=(Fahrenheit(other));
+        }
+
+        Fahrenheit &operator-=(const Dimension::Temperature &other)
+        {
+            return this->operator-=(Fahrenheit(other));
+        }
+
+        Fahrenheit operator*(double value) const
+        {
+            return Fahrenheit(value * convertFromInternal());
+        }
+
+        Fahrenheit operator/(double value) const
+        {
+            return Fahrenheit(value / convertFromInternal());
+        }
+
+        Fahrenheit operator*(int value) const
+        {
+            return Fahrenheit(value * convertFromInternal());
+        }
+
+        Fahrenheit operator/(int value) const
+        {
+            return Fahrenheit(value / convertFromInternal());
+        }
+
+        SIREUNITS_EXPORT Dimension::GeneralUnit operator+(const Dimension::GeneralUnit &other) const;
+        SIREUNITS_EXPORT Dimension::GeneralUnit operator-(const Dimension::GeneralUnit &other) const;
+        SIREUNITS_EXPORT Dimension::GeneralUnit operator*(const Dimension::GeneralUnit &other) const;
+        SIREUNITS_EXPORT Dimension::GeneralUnit operator/(const Dimension::GeneralUnit &other) const;
+
+    protected:
+        QString unitString() const
+        {
+            return "F";
+        }
+    };
 
-    Fahrenheit& operator-=(const Dimension::Temperature &other)
-    {
-        return this->operator-=(Fahrenheit(other));
-    }
-
-    Fahrenheit operator*(double value) const
-    {
-        return Fahrenheit(value * convertFromInternal());
-    }
+#ifndef SIRE_SKIP_INLINE_FUNCTIONS
 
-    Fahrenheit operator/(double value) const
+    SIRE_ALWAYS_INLINE Fahrenheit operator*(double value, const Fahrenheit &temp)
     {
-        return Fahrenheit(value / convertFromInternal());
+        return temp * value;
     }
 
-    Fahrenheit operator*(int value) const
+    SIRE_ALWAYS_INLINE Dimension::PhysUnit<0, 0, 0, 0, -1, 0, 0> operator/(double value, const Fahrenheit &temp)
     {
-        return Fahrenheit(value * convertFromInternal());
+        return Dimension::PhysUnit<0, 0, 0, 0, -1, 0, 0>(value / temp.convertFromInternal());
     }
 
-    Fahrenheit operator/(int value) const
+    SIRE_ALWAYS_INLINE Dimension::PhysUnit<0, 0, 0, 0, -1, 0, 0> operator/(int value, const Fahrenheit &temp)
     {
-        return Fahrenheit(value / convertFromInternal());
+        return Dimension::PhysUnit<0, 0, 0, 0, -1, 0, 0>(value / temp.convertFromInternal());
     }
 
-protected:
-    QString unitString() const
+    SIRE_ALWAYS_INLINE Fahrenheit operator*(int value, const Fahrenheit &temp)
     {
-        return "F";
+        return temp * value;
     }
-};
-
-#ifndef SIRE_SKIP_INLINE_FUNCTIONS
-
-SIRE_ALWAYS_INLINE Fahrenheit operator*(double value, const Fahrenheit &temp)
-{
-    return temp * value;
-}
-
-SIRE_ALWAYS_INLINE Dimension::PhysUnit<0,0,0,0,-1,0,0> operator/(double value, const Fahrenheit &temp)
-{
-    return Dimension::PhysUnit<0,0,0,0,-1,0,0>(value / temp.convertFromInternal());
-}
-
-SIRE_ALWAYS_INLINE Dimension::PhysUnit<0,0,0,0,-1,0,0> operator/(int value, const Fahrenheit &temp)
-{
-    return Dimension::PhysUnit<0,0,0,0,-1,0,0>(value / temp.convertFromInternal());
-}
-
-SIRE_ALWAYS_INLINE Fahrenheit operator*(int value, const Fahrenheit &temp)
-{
-    return temp * value;
-}
 
-#endif //SIRE_SKIP_INLINE_FUNCTIONS
+#endif // SIRE_SKIP_INLINE_FUNCTIONS
 
-const Celsius celsius(1);
-const Fahrenheit fahrenheit(1);
+    const Celsius celsius(1);
+    const Fahrenheit fahrenheit(1);
 
 }
 
-SIRE_EXPOSE_CLASS( SireUnits::Dimension::TempBase )
-SIRE_EXPOSE_CLASS( SireUnits::Celsius )
-SIRE_EXPOSE_CLASS( SireUnits::Fahrenheit )
+SIRE_EXPOSE_CLASS(SireUnits::Dimension::TempBase)
+SIRE_EXPOSE_CLASS(SireUnits::Celsius)
+SIRE_EXPOSE_CLASS(SireUnits::Fahrenheit)
 
 SIRE_END_HEADER
 
diff --git a/corelib/src/libs/SireUnits/units.h b/corelib/src/libs/SireUnits/units.h
index 5407ebce2..4acb216c4 100644
--- a/corelib/src/libs/SireUnits/units.h
+++ b/corelib/src/libs/SireUnits/units.h
@@ -28,345 +28,346 @@
 #ifndef SIREUNITS_UNITS_H
 #define SIREUNITS_UNITS_H
 
-//skip this completely when parsing with gccxml as it is broken!
+// skip this completely when parsing with gccxml as it is broken!
 #ifndef SKIP_BROKEN_GCCXML_PARTS
 
 #include <limits>
 #include <cmath>
 
 #include "dimensions.h"
+#include "generalunit.h"
 
 SIRE_BEGIN_HEADER
 
 namespace SireUnits
 {
 
-/** This file defines physical constants, in internal units of this program
+  /** This file defines physical constants, in internal units of this program
 
-    We use the AKMA units (same as charmm)
-        Angstroms, Kilocalories per Mole, Atomic mass units
+      We use the AKMA units (same as charmm)
+          Angstroms, Kilocalories per Mole, Atomic mass units
 
-    energy = kcal mol-1 (thermal)     (really MolarEnergy)
-    length = angstrom
-    mass = g mol-1                    (really MolarMass)
-    time = AKMA time == 48.88821 fs == 0.04888821 ps
-    charge = unit electrons
+      energy = kcal mol-1 (thermal)     (really MolarEnergy)
+      length = angstrom
+      mass = g mol-1                    (really MolarMass)
+      time = AKMA time == 48.88821 fs == 0.04888821 ps
+      charge = unit electrons
 
-    Where necessary, physical constants were downloaded from
-    the NIST website (web pages referenced where appropriate).
+      Where necessary, physical constants were downloaded from
+      the NIST website (web pages referenced where appropriate).
 
-    Physical constants were last checked on 28/10/2008
-*/
+      Physical constants were last checked on 28/10/2008
+  */
 
-/** Avogadro's number */
-//http://physics.nist.gov/cgi-bin/cuu/Value?na|search_for=physchem_in!
-const Dimension::Quantity mole( 6.02214179e23 );
+  /** Avogadro's number */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?na|search_for=physchem_in!
+  const Dimension::Quantity mole(6.02214179e23);
 
-const Dimension::Quantity dozen( 12 );
+  const Dimension::Quantity dozen(12);
 
-/////////////////////////////////////////////////
-// Units of angle. Internal unit = radians     //
-/////////////////////////////////////////////////
+  /////////////////////////////////////////////////
+  // Units of angle. Internal unit = radians     //
+  /////////////////////////////////////////////////
 
-const Dimension::Angle radians( 1 );
-const Dimension::Angle radian( 1 );
+  const Dimension::Angle radians(1);
+  const Dimension::Angle radian(1);
 
-const Dimension::Angle degrees = radians * pi / 180.0;
-const Dimension::Angle degree = degrees;
+  const Dimension::Angle degrees = radians * pi / 180.0;
+  const Dimension::Angle degree = degrees;
 
-const Dimension::Angle angle_minute = degree / 60;
-const Dimension::Angle angle_minutes = angle_minute;
+  const Dimension::Angle angle_minute = degree / 60;
+  const Dimension::Angle angle_minutes = angle_minute;
 
-const Dimension::Angle angle_second = angle_minute / 60;
-const Dimension::Angle angle_seconds = angle_second;
+  const Dimension::Angle angle_second = angle_minute / 60;
+  const Dimension::Angle angle_seconds = angle_second;
 
-const Dimension::Angle octant = 45 * degrees;
-const Dimension::Angle octants = octant;
+  const Dimension::Angle octant = 45 * degrees;
+  const Dimension::Angle octants = octant;
 
-const Dimension::Angle sextant = 60 * degrees;
-const Dimension::Angle sextants = sextant;
+  const Dimension::Angle sextant = 60 * degrees;
+  const Dimension::Angle sextants = sextant;
 
-const Dimension::Angle quadrant = 90 * degrees;
-const Dimension::Angle quadrants = quadrant;
+  const Dimension::Angle quadrant = 90 * degrees;
+  const Dimension::Angle quadrants = quadrant;
 
-const Dimension::Angle gradian = quadrant / 100;
-const Dimension::Angle gradians = gradian;
-const Dimension::Angle grad = gradian;
-const Dimension::Angle gon = gradian;
+  const Dimension::Angle gradian = quadrant / 100;
+  const Dimension::Angle gradians = gradian;
+  const Dimension::Angle grad = gradian;
+  const Dimension::Angle gon = gradian;
 
-const Dimension::Angle revolution = 360 * degrees;
-const Dimension::Angle revolutions = revolution;
-const Dimension::Angle revs = revolution;
+  const Dimension::Angle revolution = 360 * degrees;
+  const Dimension::Angle revolutions = revolution;
+  const Dimension::Angle revs = revolution;
 
-const Dimension::Angle circumference = revolution;
+  const Dimension::Angle circumference = revolution;
 
-/////////////////////////////////////////////////
-// Units of length. Internal unit = Angstroms  //
-/////////////////////////////////////////////////
+  /////////////////////////////////////////////////
+  // Units of length. Internal unit = Angstroms  //
+  /////////////////////////////////////////////////
 
-const Dimension::Length angstrom(1);
-const Dimension::Length angstroms = angstrom;
+  const Dimension::Length angstrom(1);
+  const Dimension::Length angstroms = angstrom;
 
-const Dimension::Length picometer( 0.01 * angstrom );
-const Dimension::Length nanometer( 1000 * picometer );
-const Dimension::Length micrometer( 1000 * nanometer );
-const Dimension::Length millimeter( 1000 * micrometer );
-const Dimension::Length centimeter( 10 * millimeter );
-const Dimension::Length meter( 100 * centimeter );
-const Dimension::Length kilometer( 1000 * meter );
+  const Dimension::Length picometer(0.01 * angstrom);
+  const Dimension::Length nanometer(1000 * picometer);
+  const Dimension::Length micrometer(1000 * nanometer);
+  const Dimension::Length millimeter(1000 * micrometer);
+  const Dimension::Length centimeter(10 * millimeter);
+  const Dimension::Length meter(100 * centimeter);
+  const Dimension::Length kilometer(1000 * meter);
 
-const Dimension::Length picometers = picometer;
-const Dimension::Length nanometers = nanometer;
-const Dimension::Length micrometers = micrometer;
-const Dimension::Length millimeters = millimeter;
-const Dimension::Length centimeters = centimeter;
-const Dimension::Length meters = meter;
-const Dimension::Length kilometers = kilometer;
+  const Dimension::Length picometers = picometer;
+  const Dimension::Length nanometers = nanometer;
+  const Dimension::Length micrometers = micrometer;
+  const Dimension::Length millimeters = millimeter;
+  const Dimension::Length centimeters = centimeter;
+  const Dimension::Length meters = meter;
+  const Dimension::Length kilometers = kilometer;
 
-//http://physics.nist.gov/cgi-bin/cuu/Value?bohrrada0|search_for=bohr
-const Dimension::Length bohr_radii( 0.52917720859 * angstrom );
+  // http://physics.nist.gov/cgi-bin/cuu/Value?bohrrada0|search_for=bohr
+  const Dimension::Length bohr_radii(0.52917720859 * angstrom);
 
-const Dimension::Length inch( 2.54 * centimeter );
-const Dimension::Length foot( 12 * inch );
-const Dimension::Length yard( 3 * foot );
-const Dimension::Length mile( 1760 * yard );
+  const Dimension::Length inch(2.54 * centimeter);
+  const Dimension::Length foot(12 * inch);
+  const Dimension::Length yard(3 * foot);
+  const Dimension::Length mile(1760 * yard);
 
-const Dimension::Length inches = inch;
-const Dimension::Length feet = foot;
-const Dimension::Length yards = yard;
-const Dimension::Length miles = mile;
+  const Dimension::Length inches = inch;
+  const Dimension::Length feet = foot;
+  const Dimension::Length yards = yard;
+  const Dimension::Length miles = mile;
 
-/////////////////////////////////////////////////
-// Units of area. Internal unit = Angstroms^2  //
-/////////////////////////////////////////////////
+  /////////////////////////////////////////////////
+  // Units of area. Internal unit = Angstroms^2  //
+  /////////////////////////////////////////////////
 
-const Dimension::Area angstrom2 = angstrom * angstrom;
-const Dimension::Area picometer2 = picometer * picometer;
-const Dimension::Area nanometer2 = nanometer * nanometer;
+  const Dimension::Area angstrom2 = angstrom * angstrom;
+  const Dimension::Area picometer2 = picometer * picometer;
+  const Dimension::Area nanometer2 = nanometer * nanometer;
 
-const Dimension::Area meter2 = meter * meter;
+  const Dimension::Area meter2 = meter * meter;
 
-/////////////////////////////////////////////////
-// Units of volume. Internal unit = Angstroms^3  //
-/////////////////////////////////////////////////
+  /////////////////////////////////////////////////
+  // Units of volume. Internal unit = Angstroms^3  //
+  /////////////////////////////////////////////////
 
-const Dimension::Volume angstrom3 = angstrom * angstrom * angstrom;
-const Dimension::Volume picometer3 = picometer * picometer * picometer;
-const Dimension::Volume nanometer3 = nanometer * nanometer * nanometer;
+  const Dimension::Volume angstrom3 = angstrom * angstrom * angstrom;
+  const Dimension::Volume picometer3 = picometer * picometer * picometer;
+  const Dimension::Volume nanometer3 = nanometer * nanometer * nanometer;
 
-const Dimension::Volume meter3 = meter * meter * meter;
+  const Dimension::Volume meter3 = meter * meter * meter;
 
-///////////////////////////////////////////////////////
-// Units of mass. Internal unit = g mol-1            //
-///////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////
+  // Units of mass. Internal unit = g mol-1            //
+  ///////////////////////////////////////////////////////
 
-const Dimension::MolarMass g_per_mol(1);
+  const Dimension::MolarMass g_per_mol(1);
 
-const Dimension::Mass gram( mole * g_per_mol );
-const Dimension::Mass kilogram( 1000 * gram );
-const Dimension::Mass tonne( 1000 * kilogram );
+  const Dimension::Mass gram(mole *g_per_mol);
+  const Dimension::Mass kilogram(1000 * gram);
+  const Dimension::Mass tonne(1000 * kilogram);
 
-const Dimension::Mass milligram( 0.001 * gram );
-const Dimension::Mass microgram( 0.001 * milligram );
-const Dimension::Mass nanogram( 0.001 * microgram );
-const Dimension::Mass picogram( 0.001 * nanogram );
-const Dimension::Mass femtogram( 0.001 * picogram );
+  const Dimension::Mass milligram(0.001 * gram);
+  const Dimension::Mass microgram(0.001 * milligram);
+  const Dimension::Mass nanogram(0.001 * microgram);
+  const Dimension::Mass picogram(0.001 * nanogram);
+  const Dimension::Mass femtogram(0.001 * picogram);
 
-const Dimension::MolarMass kg_per_mol( 1000 * g_per_mol );
-const Dimension::MolarMass tonne_per_mol( 1000 * kg_per_mol );
-const Dimension::MolarMass mg_per_mol( 0.001 * g_per_mol );
-const Dimension::MolarMass ug_per_mol( 0.001 * mg_per_mol );
-const Dimension::MolarMass ng_per_mol( 0.001 * ug_per_mol );
-const Dimension::MolarMass pg_per_mol( 0.001 * ng_per_mol );
-const Dimension::MolarMass fg_per_mol( 0.001 * pg_per_mol );
+  const Dimension::MolarMass kg_per_mol(1000 * g_per_mol);
+  const Dimension::MolarMass tonne_per_mol(1000 * kg_per_mol);
+  const Dimension::MolarMass mg_per_mol(0.001 * g_per_mol);
+  const Dimension::MolarMass ug_per_mol(0.001 * mg_per_mol);
+  const Dimension::MolarMass ng_per_mol(0.001 * ug_per_mol);
+  const Dimension::MolarMass pg_per_mol(0.001 * ng_per_mol);
+  const Dimension::MolarMass fg_per_mol(0.001 * pg_per_mol);
 
-///////////////////////////////////////////////////////
-// Units of Charge. Internal unit = |e|              //
-///////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////
+  // Units of Charge. Internal unit = |e|              //
+  ///////////////////////////////////////////////////////
 
-const Dimension::Charge mod_electron(1);
-const Dimension::MolarCharge faraday(1);
+  const Dimension::Charge mod_electron(1);
+  const Dimension::MolarCharge faraday(1);
 
-//http://physics.nist.gov/cgi-bin/cuu/Value?e|search_for=elecmag_in!
-const Dimension::Charge coulomb = mod_electron / 1.602176487e-19;
-const Dimension::MolarCharge coulomb_per_mol = coulomb / mole;
+  // http://physics.nist.gov/cgi-bin/cuu/Value?e|search_for=elecmag_in!
+  const Dimension::Charge coulomb = mod_electron / 1.602176487e-19;
+  const Dimension::MolarCharge coulomb_per_mol = coulomb / mole;
 
-const Dimension::Charge e_charge = -mod_electron;
+  const Dimension::Charge e_charge = -mod_electron;
 
-/////////////////////////////////////////////////
-// Units of Energy. Internal unit = kcal mol-1 //
-/////////////////////////////////////////////////
+  /////////////////////////////////////////////////
+  // Units of Energy. Internal unit = kcal mol-1 //
+  /////////////////////////////////////////////////
 
-const Dimension::MolarEnergy kcal_per_mol(1);
-const Dimension::Energy kcal = mole * kcal_per_mol;
+  const Dimension::MolarEnergy kcal_per_mol(1);
+  const Dimension::Energy kcal = mole * kcal_per_mol;
 
-const Dimension::MolarEnergy cal_per_mol = 0.001 * kcal_per_mol;
-const Dimension::Energy cal = 0.001 * kcal;
+  const Dimension::MolarEnergy cal_per_mol = 0.001 * kcal_per_mol;
+  const Dimension::Energy cal = 0.001 * kcal;
 
-const Dimension::MolarEnergy kJ_per_mol = kcal_per_mol / 4.184;
-const Dimension::Energy kilojoule = mole * kJ_per_mol;
+  const Dimension::MolarEnergy kJ_per_mol = kcal_per_mol / 4.184;
+  const Dimension::Energy kilojoule = mole * kJ_per_mol;
 
-const Dimension::MolarEnergy MJ_per_mol = 1000 * kJ_per_mol;
-const Dimension::Energy megajoule = 1000 * kilojoule;
+  const Dimension::MolarEnergy MJ_per_mol = 1000 * kJ_per_mol;
+  const Dimension::Energy megajoule = 1000 * kilojoule;
 
-const Dimension::MolarEnergy J_per_mol = 0.001 * kJ_per_mol;
-const Dimension::Energy joule = 0.001 * kilojoule;
+  const Dimension::MolarEnergy J_per_mol = 0.001 * kJ_per_mol;
+  const Dimension::Energy joule = 0.001 * kilojoule;
 
-/** Conversion factor from international kcal mol-1 to internal units  */
-const Dimension::MolarEnergy int_kcal_per_mol( 4.1868 * kJ_per_mol );
-const Dimension::MolarEnergy int_cal_per_mol( 0.001 * int_kcal_per_mol );
+  /** Conversion factor from international kcal mol-1 to internal units  */
+  const Dimension::MolarEnergy int_kcal_per_mol(4.1868 * kJ_per_mol);
+  const Dimension::MolarEnergy int_cal_per_mol(0.001 * int_kcal_per_mol);
 
-const Dimension::Energy int_kcal( mole * int_kcal_per_mol );
-const Dimension::Energy int_cal( 0.001 * int_kcal );
+  const Dimension::Energy int_kcal(mole *int_kcal_per_mol);
+  const Dimension::Energy int_cal(0.001 * int_kcal);
 
-//http://physics.nist.gov/cgi-bin/cuu/Value?hr|search_for=hartree
-const Dimension::Energy hartree(4.35974394e-18 * joule);
+  // http://physics.nist.gov/cgi-bin/cuu/Value?hr|search_for=hartree
+  const Dimension::Energy hartree(4.35974394e-18 * joule);
 
-////////////////////////////////////////////////////////////
-// Units of time. Internal unit = akma_time == 48.8882 fs //
-////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////
+  // Units of time. Internal unit = akma_time == 48.8882 fs //
+  ////////////////////////////////////////////////////////////
 
-const Dimension::Time akma_time(1);
+  const Dimension::Time akma_time(1);
 
-const Dimension::Time second( std::sqrt( (kg_per_mol * meter * meter) / J_per_mol ) );
-const Dimension::Time millisecond = 0.001 * second;
-const Dimension::Time microsecond = 0.001 * millisecond;
-const Dimension::Time nanosecond = 0.001 * microsecond;
-const Dimension::Time picosecond = 0.001 * nanosecond;
-const Dimension::Time femtosecond = 0.001 * picosecond;
+  const Dimension::Time second(std::sqrt((kg_per_mol * meter * meter) / J_per_mol));
+  const Dimension::Time millisecond = 0.001 * second;
+  const Dimension::Time microsecond = 0.001 * millisecond;
+  const Dimension::Time nanosecond = 0.001 * microsecond;
+  const Dimension::Time picosecond = 0.001 * nanosecond;
+  const Dimension::Time femtosecond = 0.001 * picosecond;
 
-const Dimension::Time minute( 60 * second );
-const Dimension::Time hour( 60 * minute );
-const Dimension::Time day( 24 * hour );
-const Dimension::Time week( 7 * day );
-const Dimension::Time fortnight( 2 * week );
+  const Dimension::Time minute(60 * second);
+  const Dimension::Time hour(60 * minute);
+  const Dimension::Time day(24 * hour);
+  const Dimension::Time week(7 * day);
+  const Dimension::Time fortnight(2 * week);
 
-/////////////////////////////////////////////////////////////
-// Units of velocity. Internal unit = Angstrom / AKMA time //
-/////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////
+  // Units of velocity. Internal unit = Angstrom / AKMA time //
+  /////////////////////////////////////////////////////////////
 
-const Dimension::Velocity akma_velocity(1);
+  const Dimension::Velocity akma_velocity(1);
 
-const Dimension::Velocity angstroms_per_fs( angstrom / femtosecond );
-const Dimension::Velocity meters_per_second( meter / second );
-const Dimension::Velocity kilometers_per_hour( kilometer / hour );
-const Dimension::Velocity miles_per_hour( mile / hour );
-const Dimension::Velocity mph = miles_per_hour;
-const Dimension::Velocity kph = kilometers_per_hour;
+  const Dimension::Velocity angstroms_per_fs(angstrom / femtosecond);
+  const Dimension::Velocity meters_per_second(meter / second);
+  const Dimension::Velocity kilometers_per_hour(kilometer / hour);
+  const Dimension::Velocity miles_per_hour(mile / hour);
+  const Dimension::Velocity mph = miles_per_hour;
+  const Dimension::Velocity kph = kilometers_per_hour;
 
-//////////////////////////////////////////////////////////
-// Units of force. Internal units = kcal mol-1 A-1      //
-//////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////
+  // Units of force. Internal units = kcal mol-1 A-1      //
+  //////////////////////////////////////////////////////////
 
-/** Convert a force in Newtons to internal units */
-const Dimension::Force newton( joule / meter );
+  /** Convert a force in Newtons to internal units */
+  const Dimension::Force newton(joule / meter);
 
-/** Weights */
-const Dimension::Force ounce = 0.27801385095 * newton;
-const Dimension::Force pound = 16 * ounce;
-const Dimension::Force stone = 14 * pound;
-const Dimension::Force hundredweight = 8 * stone;
+  /** Weights */
+  const Dimension::Force ounce = 0.27801385095 * newton;
+  const Dimension::Force pound = 16 * ounce;
+  const Dimension::Force stone = 14 * pound;
+  const Dimension::Force hundredweight = 8 * stone;
 
-//////////////////////////////////////////////////////////
-// Units of pressure. Internal units = kcal mol-1 A-2   //
-//////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////
+  // Units of pressure. Internal units = kcal mol-1 A-2   //
+  //////////////////////////////////////////////////////////
 
-const Dimension::Pressure pascal = newton / (meter*meter);
+  const Dimension::Pressure pascal = newton / (meter * meter);
 
-const Dimension::Pressure bar = 100000 * pascal;
-const Dimension::Pressure atm = 101325 * pascal;
+  const Dimension::Pressure bar = 100000 * pascal;
+  const Dimension::Pressure atm = 101325 * pascal;
 
-const Dimension::Pressure psi = pound / (inch*inch);
-const Dimension::Pressure mmHg = 133.322 * pascal;
+  const Dimension::Pressure psi = pound / (inch * inch);
+  const Dimension::Pressure mmHg = 133.322 * pascal;
 
-//////////////////////////////////////////////////////////
-// Units of temperature. Internal units = Kelvin        //
-//////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////
+  // Units of temperature. Internal units = Kelvin        //
+  //////////////////////////////////////////////////////////
 
-const Dimension::Temperature kelvin(1);
+  const Dimension::Temperature kelvin(1);
 
-// other temperature units defined in temperature.h
+  // other temperature units defined in temperature.h
 
-//////////////////////////////////////////////////////////
-// Now some miscellaneous units                         //
-//////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////
+  // Now some miscellaneous units                         //
+  //////////////////////////////////////////////////////////
 
-/** Convert the units of current (amps) */
-const Dimension::Current amp = coulomb / second;
+  /** Convert the units of current (amps) */
+  const Dimension::Current amp = coulomb / second;
 
-/** Volts */
-const Dimension::Potential volt = joule / coulomb;
+  /** Volts */
+  const Dimension::Potential volt = joule / coulomb;
 
-/** Convert the units of capacitance (farads) */
-const Dimension::Capacitance farad = coulomb / volt;
+  /** Convert the units of capacitance (farads) */
+  const Dimension::Capacitance farad = coulomb / volt;
 
-/** Convert power in Watts */
-const Dimension::Power watt = joule / second;
-const Dimension::MolarPower watt_per_mol = J_per_mol / second;
+  /** Convert power in Watts */
+  const Dimension::Power watt = joule / second;
+  const Dimension::MolarPower watt_per_mol = J_per_mol / second;
 
-///////////////////////////////////////////////////////////
-// Now physical constants converted into internal units. //
-//  The values of these are taken from the 1998 CODATA   //
-//  values - see fundemental_constants.pdf in techdocs   //
-///////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////
+  // Now physical constants converted into internal units. //
+  //  The values of these are taken from the 1998 CODATA   //
+  //  values - see fundemental_constants.pdf in techdocs   //
+  ///////////////////////////////////////////////////////////
 
-/** Speed of light in a vacuum */
-//http://physics.nist.gov/cgi-bin/cuu/Value?c|search_for=c
-const Dimension::Velocity c = 299792458 * (meter / second);
+  /** Speed of light in a vacuum */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?c|search_for=c
+  const Dimension::Velocity c = 299792458 * (meter / second);
 
-/** Epsilon_0 (electrostatic constant) 8.854187817e-12 F m-1 */
-//http://physics.nist.gov/cgi-bin/cuu/Value?ep0|search_for=permittivity
-const double epsilon0 = 8.854187817e-12 * (farad / meter);
+  /** Epsilon_0 (electrostatic constant) 8.854187817e-12 F m-1 */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?ep0|search_for=permittivity
+  const Dimension::GeneralUnit epsilon0(8.854187817e-12 * (farad / meter));
 
-/** 4 * pi * epsilon_0 */
-const double four_pi_eps0 = 4.0 * SireMaths::pi * epsilon0;
+  /** 4 * pi * epsilon_0 */
+  const Dimension::GeneralUnit four_pi_eps0(4.0 * SireMaths::pi * epsilon0);
 
-/** 1 / (4 * pi * epsilon0) */
-const double one_over_four_pi_eps0 = 1.0 / four_pi_eps0;
+  /** 1 / (4 * pi * epsilon0) */
+  const Dimension::GeneralUnit one_over_four_pi_eps0(1.0 / four_pi_eps0);
 
-/** Gas constant (8.314472 J mol-1 K-1) */
-//http://physics.nist.gov/cgi-bin/cuu/Value?r|search_for=gas
-const double gasr = 8.314472 * (J_per_mol / kelvin);
+  /** Gas constant (8.314472 J mol-1 K-1) */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?r|search_for=gas
+  const Dimension::GeneralUnit gasr(8.314472 * (J_per_mol / kelvin));
 
-/** Boltzmann constant J K-1 (is equal to gasr in internal units of kcal mol-1 K-1) */
-const double k_boltz = gasr;
+  /** Boltzmann constant J K-1 (is equal to gasr in internal units of kcal mol-1 K-1) */
+  const Dimension::GeneralUnit k_boltz = gasr;
 
-/** Magnetic constant, mu0, 4pi * 10-7 N A-2 */
-const double mu0 = 4.0e-7 * pi * (newton / (amp*amp));
+  /** Magnetic constant, mu0, 4pi * 10-7 N A-2 */
+  const Dimension::GeneralUnit mu0(4.0e-7 * pi * (newton / (amp * amp)));
 
-/** Newton's gravitational constant */
-//http://physics.nist.gov/cgi-bin/cuu/Value?bg|search_for=gravitational
-const double G_newton = 6.67428e-11 * ((meter*meter*meter) / (kilogram * second * second));
+  /** Newton's gravitational constant */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?bg|search_for=gravitational
+  const Dimension::GeneralUnit G_newton(6.67428e-11 * ((meter * meter * meter) / (kilogram * second * second)));
 
-/** Acceleration due to gravity on Earth */
-const Dimension::Acceleration g_accel = 9.8 * meter / (second*second);
+  /** Acceleration due to gravity on Earth */
+  const Dimension::Acceleration g_accel = 9.8 * meter / (second * second);
 
-/** Planck's constant */
-//http://physics.nist.gov/cgi-bin/cuu/Value?h|search_for=planck
-const double h_planck = 6.62606896e-34 * (joule * second);
+  /** Planck's constant */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?h|search_for=planck
+  const Dimension::GeneralUnit h_planck(6.62606896e-34 * (joule * second));
 
-/** Plank / 2pi */
-const double h_slash = h_planck / (2.0*pi);
+  /** Plank / 2pi */
+  const Dimension::GeneralUnit h_slash(h_planck / (2.0 * pi));
 
-/** Mass of an electron */
-//http://physics.nist.gov/cgi-bin/cuu/Value?me|search_for=mass
-const Dimension::Mass electron_mass = 9.10938215e-31 * kilogram;
+  /** Mass of an electron */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?me|search_for=mass
+  const Dimension::Mass electron_mass = 9.10938215e-31 * kilogram;
 
-/** Mass of a proton */
-//http://physics.nist.gov/cgi-bin/cuu/Value?mp|search_for=mass
-const Dimension::Mass proton_mass = 1.672621637e-27 * kilogram;
+  /** Mass of a proton */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?mp|search_for=mass
+  const Dimension::Mass proton_mass = 1.672621637e-27 * kilogram;
 
-/** Mass of a neutron */
-//http://physics.nist.gov/cgi-bin/cuu/Value?mn|search_for=mass
-const Dimension::Mass neutron_mass = 1.674927211e-27 * kilogram;
+  /** Mass of a neutron */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?mn|search_for=mass
+  const Dimension::Mass neutron_mass = 1.674927211e-27 * kilogram;
 
-/** Atomic mass constant */
-//http://physics.nist.gov/cgi-bin/cuu/Value?u|search_for=mass
-const Dimension::Mass atomic_mass_constant = 1.660538782e-27 * kilogram;
+  /** Atomic mass constant */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?u|search_for=mass
+  const Dimension::Mass atomic_mass_constant = 1.660538782e-27 * kilogram;
 
-/** Molar volume of an ideal gas  (273.15 K, 101.325 kPa) */
-//http://physics.nist.gov/cgi-bin/cuu/Value?mvolstd|search_for=molar+volume
-const Dimension::MolarVolume molar_volume = 22.413996e-3 * (meter*meter*meter) / mole;
+  /** Molar volume of an ideal gas  (273.15 K, 101.325 kPa) */
+  // http://physics.nist.gov/cgi-bin/cuu/Value?mvolstd|search_for=molar+volume
+  const Dimension::MolarVolume molar_volume = 22.413996e-3 * (meter * meter * meter) / mole;
 
 }
 
diff --git a/doc/source/cheatsheet/search.rst b/doc/source/cheatsheet/search.rst
index c8ac94986..ca2d4f07c 100644
--- a/doc/source/cheatsheet/search.rst
+++ b/doc/source/cheatsheet/search.rst
@@ -213,7 +213,7 @@ as the result. This can be summarised as a table.
 +----------+---------------------+---------------------+------------------------+----------------------+------------------------+----------------------+
 | Chain    | chains with atom    | chains with bond    | chains with residue    | N/A                  | chains in segment      | chains in molecule   |
 +----------+---------------------+---------------------+------------------------+----------------------+------------------------+----------------------+
-| Segment  | segments with atomv | segments with bond  | segments with residue  | segments with chain  | N/A                    | segments in molecule |
+| Segment  | segments with atoms | segments with bond  | segments with residue  | segments with chain  | N/A                    | segments in molecule |
 +----------+---------------------+---------------------+------------------------+----------------------+------------------------+----------------------+
 | Molecule | molecules with atom | molecules with bond | molecules with residue | molecules with chain | molecules with segment | N/A                  |
 +----------+---------------------+---------------------+------------------------+----------------------+------------------------+----------------------+
@@ -402,7 +402,7 @@ For example;
 * ``atoms in residues with count(atomname CA) == 1`` - match all atoms
   in residues that contain a single atom called ``CA``
 * ``(molecules with count(element O) == 1) and (molecules with count(element H) == 2) and (molecules with count(atoms) == 3)`` -
-  match all molecules that contain there atoms, and that have one oxygen atom
+  match all molecules that contain three atoms, and that have one oxygen atom
   and have two hydrogen atoms (i.e. are water molecules).
 
 Searching by Charge or Mass
@@ -453,7 +453,7 @@ imprecision issues experienced when searching for views by charge.
 The approximate comparison operators are;
 
 * ``=~`` - approximate equal to. :func:`sire.search.approx_equal`
-* ``!~`` - not approximates equal to. :func:`sire.search_approx_not_equal`
+* ``!~`` - not approximates equal to. :func:`sire.search.approx_not_equal`
 * ``>~`` - greater than (but not approximately equal to). :func:`sire.search.approx_greater`
 * ``<~`` - less than (but not approximately equal to). :func:`sire.search.approx_less`
 * ``>=~`` - greater than or approximately equal to. :func:`sire.search.approx_greater_equal`
diff --git a/doc/source/conf.py b/doc/source/conf.py
index 0d1781ce7..57e70eb71 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -7,8 +7,6 @@
 from __future__ import print_function
 
 import sire
-import sys
-import glob
 import os
 
 # -- General configuration -----------------------------------------------
@@ -17,33 +15,33 @@
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 
 extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.viewcode',
-    'sphinx.ext.autosummary',
-    'sphinx.ext.napoleon',
-    'sphinx.ext.mathjax',
-    'sphinxcontrib.programoutput',
-    'sphinx_issues',
+    "sphinx.ext.autodoc",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.mathjax",
+    "sphinxcontrib.programoutput",
+    "sphinx_issues",
 ]
 
 # Github repo
-issues_github_path = 'openbiosim/sire'
+issues_github_path = "openbiosim/sire"
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # The suffix of source filenames.
-source_suffix = '.rst'
+source_suffix = ".rst"
 
 # The encoding of source files.
 # source_encoding = 'utf-8-sig'
 
 # The master toctree document.
-master_doc = 'index'
+master_doc = "index"
 
 # General information about the project.
-project = u'sire'
-copyright = u'2006-2022'
+project = "sire"
+copyright = "2006-2022"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -76,7 +74,7 @@
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
-language = 'en'
+language = "en"
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
@@ -86,9 +84,9 @@
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = ['_build', '*_test*']
+exclude_patterns = ["_build", "*_test*"]
 
-# The reST default role (used for this markup: `text`) to use for all documents.
+# The reST default role (used for this markup: `text`) to use for all documents
 default_role = "autolink"
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
@@ -96,29 +94,31 @@
 
 # If true, the current module name will be prepended to all description
 # unit titles (such as .. function::).
-#add_module_names = True
+# add_module_names = True
 
 # If true, sectionauthor and moduleauthor directives will be shown in the
 # output. They are ignored by default.
 show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+pygments_style = "sphinx"
 
 # A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
+# modindex_common_prefix = []
 
 
 # -- options for mathjax
 # note there is no protocol given here to avoid mixing http with https
 # see: http://docs.mathjax.org/en/latest/start.html#secure-cdn-access
-mathjax_path = ("https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/MathJax.js?"
-                "config=TeX-AMS-MML_HTMLorMML")
+mathjax_path = (
+    "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/MathJax.js?"
+    "config=TeX-AMS-MML_HTMLorMML"
+)
 
 # -- Options for HTML output ---------------------------------------------
 
 # theme
-html_theme = 'furo'
+html_theme = "furo"
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
@@ -128,23 +128,26 @@
     "light_css_variables": {
         "font-stack": "Changa, sans-serif",
         "font-stack--monospace": "Roboto Mono, monospace",
-        "color-foreground-primary": "#dddddd",     # main text and headings
-        "color-foreground-secondary": "#cccccc",    # secondary text
-        "color-foreground-muted" : "#d0d0d0",      # muted text
-        "color-foreground-border": "#923eb1",      # for content borders
-        "color-background-primary": "#160f30",     # for content
-        "color-background-secondary": "#201146", # for navigation + ToC
-        "color-background-hover": "#4f4fb0",   # for navigation-item hover
+        "color-foreground-primary": "#dddddd",  # main text and headings
+        "color-foreground-secondary": "#cccccc",  # secondary text
+        "color-foreground-muted": "#d0d0d0",  # muted text
+        "color-foreground-border": "#923eb1",  # for content borders
+        "color-background-primary": "#160f30",  # for content
+        "color-background-secondary": "#201146",  # for navigation + ToC
+        "color-background-hover": "#4f4fb0",  # for navigation-item hover
         "color-background-hover--transparent": "#4f4fb000",
-        "color-background-border": "#403333",    # for UI borders
-        "color-background-item": "#411a30",      # for "background" items (eg: copybutton)
-        "color-announcement-background": "#000000dd",    # announcements
-        "color-announcement-text": "#eeebee",            # announcements
-        "color-admonition-title-background--note": "#FFFFFF33", # Note background
-        "color-admonition-title-background--warning": "#FF000033", # Warning background
-        "color-admonition-background": "#FFFFFF11", # Admonition backgrounds
-        "color-brand-primary": "#eeeeee",        # brand colors (sidebar titles)
-        "color-brand-content": "#00dfef",        # brand colors (hyperlink color)
+        "color-background-border": "#403333",  # for UI borders
+        "color-background-item": "#411a30",  # for "background" items
+        # (eg: copybutton)
+        "color-announcement-background": "#000000dd",  # announcements
+        "color-announcement-text": "#eeebee",  # announcements
+        "color-admonition-title-background--note": "#FFFFFF33",
+        # Note background
+        "color-admonition-title-background--warning": "#FF000033",
+        # Warning background
+        "color-admonition-background": "#FFFFFF11",  # Admonition backgrounds
+        "color-brand-primary": "#eeeeee",  # brand colors (sidebar titles)
+        "color-brand-content": "#00dfef",  # brand colors (hyperlink color)
         "color-highlight-on-target": "#333300",  # Highlighted text background
     },
 }
@@ -171,46 +174,44 @@
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-html_favicon = None
+html_favicon = "images/favicon.png"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+html_static_path = ["_static"]
 
 html_css_files = [
-    'css/custom_fonts.css',
-    'css/custom_style.css',
-    'css/custom_pygments.css'
+    "css/custom_fonts.css",
+    "css/custom_style.css",
+    "css/custom_pygments.css",
 ]
 
-html_js_files = [
-    'js/custom.js'
-]
+html_js_files = ["js/custom.js"]
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
-html_last_updated_fmt = '%b %d, %Y'
+html_last_updated_fmt = "%b %d, %Y"
 
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
 html_use_smartypants = True
 
 # Custom sidebar templates, maps document names to template names.
-#html_sidebars = {'**': ['sourcelink.html', 'globaltoc.html']}
+# html_sidebars = {'**': ['sourcelink.html', 'globaltoc.html']}
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
-#html_additional_pages = {}
+# html_additional_pages = {}
 
 # If false, no module index is generated.
-#html_domain_indices = True
+# html_domain_indices = True
 
 # If false, no index is generated.
-#html_use_index = True
+# html_use_index = True
 
 # If true, the index is split into individual pages for each letter.
-#html_split_index = False
+# html_split_index = False
 
 # If true, links to the reST sources are added to the pages.
 html_show_sourcelink = False
@@ -224,13 +225,13 @@
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
 # base URL from which the finished HTML is served.
-#html_use_opensearch = ''
+# html_use_opensearch = ''
 
 # This is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = None
+# html_file_suffix = None
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = 'SireDoc'
+htmlhelp_basename = "SireDoc"
 
 
 # -- Options for LaTeX output --------------------------------------------
@@ -238,53 +239,47 @@
 latex_elements = {
     # The paper size ('letterpaper' or 'a4paper').
     # 'papersize': 'letterpaper',
-
     # The font size ('10pt', '11pt' or '12pt').
     # 'pointsize': '10pt',
-
     # Additional stuff for the LaTeX preamble.
-    'preamble': r"\usepackage{amsmath,amssymb}",
+    "preamble": r"\usepackage{amsmath,amssymb}",
 }
 
 # Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title, author, documentclass [howto/manual]).
+# (source start file, target name, title, author, documentclass [howto/manual])
 latex_documents = [
-    ('index', 'sire.tex', u'Sire Documentation',
-     u'Michel Lab', 'manual'),
+    ("index", "sire.tex", "Sire Documentation", "OpenBioSim", "manual"),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.
-#latex_logo = None
+# latex_logo = None
 
 # For "manual" documents, if this is true, then toplevel headings are parts,
 # not chapters.
-#latex_use_parts = False
+# latex_use_parts = False
 
 # If true, show page references after internal links.
-#latex_show_pagerefs = False
+# latex_show_pagerefs = False
 
 # If true, show URL addresses after external links.
-#latex_show_urls = False
+# latex_show_urls = False
 
 # Documents to append as an appendix to all manuals.
-#latex_appendices = []
+# latex_appendices = []
 
 # If false, no module index is generated.
-#latex_domain_indices = True
+# latex_domain_indices = True
 
 
 # -- Options for manual page output --------------------------------------
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [
-    ('index', 'Sire', u'Sire Documentation',
-     [""], 1)
-]
+man_pages = [("index", "Sire", "Sire Documentation", [""], 1)]
 
 # If true, show URL addresses after external links.
-#man_show_urls = False
+# man_show_urls = False
 
 
 # -- Options for Texinfo output ------------------------------------------
@@ -293,20 +288,25 @@
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    ('index', 'Sire', u'Sire Documentation',
-     "", 'Sire',
-     'Sire molecular simulation framework.',
-     'Miscellaneous'),
+    (
+        "index",
+        "Sire",
+        "Sire Documentation",
+        "",
+        "Sire",
+        "Sire molecular simulation framework.",
+        "Miscellaneous",
+    ),
 ]
 
 # Documents to append as an appendix to all manuals.
-#texinfo_appendices = []
+# texinfo_appendices = []
 
 # If false, no module index is generated.
-#texinfo_domain_indices = True
+# texinfo_domain_indices = True
 
 # How to display URL addresses: 'footnote', 'no', or 'inline'.
-#texinfo_show_urls = 'footnote'
+# texinfo_show_urls = 'footnote'
 
 # -----------------------------------------------------------------------------
 # Autosummary
@@ -314,14 +314,13 @@
 
 autosummary_generate = True
 autodoc_default_options = {
-    'members': None,  # Include all members (methods).
-    'special-members': False,
-    'exclude-members': '__dict__,__weakref__',  # Exclude "standard" methods.
+    "members": None,  # Include all members (methods).
+    "special-members": False,
+    "exclude-members": "__dict__,__weakref__",  # Exclude "standard" methods.
     "private-members": False,
 }
 
 # spell checking
-spelling_lang = 'en_US'
-spelling_word_list_filename = 'spelling_wordlist.txt'
+spelling_lang = "en_US"
+spelling_word_list_filename = "spelling_wordlist.txt"
 spelling_show_suggestions = True
-
diff --git a/doc/source/features.rst b/doc/source/features.rst
index c976c7cf6..56c7f104b 100644
--- a/doc/source/features.rst
+++ b/doc/source/features.rst
@@ -5,7 +5,7 @@ Features
 :mod:`sire` is a powerful Python/C++ module for loading and manipulating
 molecular (predominantly biomolecular) systems.
 
-* :doc:`Load an save <tutorial/part01/02_loading_a_molecule>`
+* :doc:`Load and save <tutorial/part01/02_loading_a_molecule>`
   molecules from a number of
   :doc:`molecular file formats <tutorial/part01/06_supported_file_formats>`.
   This includes Amber, CHARMM and GROMACS files.
diff --git a/doc/source/images/favicon.png b/doc/source/images/favicon.png
new file mode 100644
index 000000000..abedad0c6
Binary files /dev/null and b/doc/source/images/favicon.png differ
diff --git a/doc/source/images/logo.svg b/doc/source/images/logo.svg
index af2baf0f3..ccea389f5 100644
--- a/doc/source/images/logo.svg
+++ b/doc/source/images/logo.svg
@@ -1,67 +1,8 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 <svg width="100%" height="100%" viewBox="0 0 2048 736" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
-    <g id="logo.svg" transform="matrix(4.98297,0,0,4.98297,1024,209.285)">
-        <g transform="matrix(1,0,0,1,-205.5,-42)">
-            <g transform="matrix(1,0,0,1,0.78,0)">
-                <g id="Images">
-                    <g id="obs-logo-mono">
-                        <g id="OPENBIOSIM" transform="matrix(1,0,0,1,94.22,18)">
-                            <g id="BIOSIM" transform="matrix(1,0,0,1,160,0)">
-                                <path id="Combined-Shape" d="M10.526,1C13.076,1 15.239,1.489 17.013,2.468C18.788,3.447 20.146,4.721 21.089,6.291C22.032,7.861 22.503,9.551 22.503,11.361C22.503,13.171 22.17,14.713 21.505,15.987C20.839,17.261 20.035,18.286 19.093,19.062C18.15,19.838 17.254,20.355 16.403,20.614L16.403,20.946C17.586,21.278 18.76,21.842 19.924,22.636C21.089,23.43 22.059,24.492 22.836,25.822C23.612,27.151 24,28.777 24,30.697C24,32.581 23.547,34.382 22.641,36.099C21.736,37.817 20.313,39.23 18.372,40.338C16.431,41.446 13.89,42 10.748,42L0,42L0,38.232L10.637,38.232C12.781,38.232 14.518,37.854 15.849,37.097C17.18,36.339 18.159,35.37 18.788,34.188C19.416,33.006 19.73,31.787 19.73,30.531C19.73,29.238 19.416,28.01 18.788,26.847C18.159,25.683 17.18,24.723 15.849,23.966C14.518,23.208 12.781,22.83 10.637,22.83L0,22.829L0,19.339L10.359,19.339C12.208,19.339 13.723,18.979 14.906,18.259C16.089,17.539 16.958,16.624 17.512,15.516C18.067,14.408 18.344,13.245 18.344,12.026C18.344,10.807 18.067,9.643 17.512,8.535C16.958,7.427 16.089,6.522 14.906,5.82C13.723,5.118 12.208,4.768 10.359,4.768L0,4.767L0,1L10.526,1Z" style="fill:white;fill-rule:nonzero;"/>
-                                <rect id="Path" x="26" y="1" width="4" height="41" style="fill:white;fill-rule:nonzero;"/>
-                                <path id="Shape" d="M52.5,42C49.305,42 46.487,41.401 44.044,40.204C41.602,39.007 39.564,37.404 37.93,35.396C36.296,33.388 35.066,31.132 34.239,28.626C33.413,26.121 33,23.561 33,20.945C33,18.366 33.413,15.824 34.239,13.318C35.066,10.813 36.296,8.557 37.93,6.549C39.564,4.541 41.602,2.947 44.044,1.768C46.487,0.589 49.305,0 52.5,0C55.695,0 58.504,0.589 60.928,1.768C63.352,2.947 65.381,4.541 67.015,6.549C68.649,8.557 69.888,10.813 70.733,13.318C71.578,15.824 72,18.366 72,20.945C72,23.561 71.578,26.121 70.733,28.626C69.888,31.132 68.649,33.388 67.015,35.396C65.381,37.404 63.352,39.007 60.928,40.204C58.504,41.401 55.695,42 52.5,42ZM52.5,38.021C55.475,38.021 58.1,37.275 60.377,35.783C62.654,34.291 64.435,32.255 65.72,29.676C67.006,27.097 67.648,24.187 67.648,20.945C67.648,17.739 67.006,14.857 65.72,12.296C64.435,9.736 62.654,7.709 60.377,6.217C58.1,4.725 55.475,3.979 52.5,3.979C49.489,3.979 46.845,4.725 44.568,6.217C42.291,7.709 40.51,9.736 39.225,12.296C37.939,14.857 37.297,17.739 37.297,20.945C37.297,24.187 37.939,27.097 39.225,29.676C40.51,32.255 42.291,34.291 44.568,35.783C46.845,37.275 49.489,38.021 52.5,38.021Z" style="fill:white;fill-rule:nonzero;"/>
-                                <path id="Path1" serif:id="Path" d="M90.087,42C87.665,42 85.607,41.696 83.912,41.088C82.217,40.48 80.82,39.697 79.722,38.739C78.623,37.782 77.747,36.768 77.095,35.7C76.443,34.632 75.969,33.618 75.671,32.661C75.373,31.703 75.186,30.92 75.112,30.312C75.037,29.704 75,29.4 75,29.4L79.358,29.4C79.358,29.4 79.405,29.695 79.498,30.284C79.591,30.874 79.815,31.601 80.169,32.467C80.522,33.333 81.091,34.199 81.873,35.064C82.655,35.93 83.717,36.649 85.058,37.22C86.399,37.791 88.112,38.076 90.198,38.076C93.03,38.076 95.32,37.358 97.071,35.921C98.822,34.484 99.697,32.624 99.697,30.339C99.697,28.203 98.999,26.582 97.602,25.476C96.205,24.371 94.371,23.542 92.098,22.989L86.79,21.718C84.778,21.203 82.972,20.512 81.37,19.646C79.768,18.78 78.502,17.657 77.57,16.275C76.639,14.893 76.173,13.189 76.173,11.163C76.173,8.842 76.751,6.853 77.906,5.195C79.06,3.537 80.625,2.257 82.599,1.354C84.574,0.451 86.827,0 89.36,0C91.893,0 93.979,0.387 95.618,1.161C97.258,1.934 98.561,2.883 99.53,4.007C100.498,5.13 101.215,6.263 101.681,7.405C102.147,8.547 102.445,9.505 102.575,10.279C102.706,11.053 102.771,11.439 102.771,11.439L98.524,11.439C98.524,11.439 98.487,11.182 98.412,10.666C98.338,10.15 98.142,9.514 97.826,8.759C97.509,8.004 97.015,7.249 96.345,6.493C95.674,5.738 94.762,5.103 93.607,4.587C92.452,4.071 90.999,3.813 89.249,3.813C86.343,3.813 84.145,4.522 82.655,5.941C81.165,7.359 80.42,9.008 80.42,10.887C80.42,12.618 81.025,14 82.236,15.032C83.447,16.063 85.132,16.837 87.293,17.353L92.936,18.734C95.06,19.25 96.95,19.987 98.608,20.945C100.266,21.903 101.579,23.137 102.547,24.647C103.516,26.158 104,27.982 104,30.118C104,32.255 103.451,34.226 102.352,36.032C101.253,37.837 99.67,39.283 97.602,40.37C95.535,41.457 93.03,42 90.087,42Z" style="fill:white;fill-rule:nonzero;"/>
-                                <rect id="Path2" serif:id="Path" x="108" y="1" width="4" height="41" style="fill:white;fill-rule:nonzero;"/>
-                                <path id="Combined-Shape1" serif:id="Combined-Shape" d="M126.706,1L137,26.597L150.294,1L156,1L156,42L151.79,42L151.79,7.095L138.994,31.473L135.006,31.473L124,5.686L124,42L120,42L120,1L126.706,1Z" style="fill:white;fill-rule:nonzero;"/>
-                            </g>
-                            <g id="OPEN">
-                                <path id="Shape1" serif:id="Shape" d="M21.028,42C17.523,42 14.461,41.401 11.842,40.204C9.223,39.007 7.037,37.404 5.285,35.396C3.532,33.388 2.213,31.132 1.328,28.626C0.443,26.121 0,23.561 0,20.945C0,18.329 0.443,15.778 1.328,13.291C2.213,10.804 3.532,8.566 5.285,6.576C7.037,4.587 9.223,2.993 11.842,1.796C14.461,0.599 17.523,0 21.028,0C24.495,0 27.539,0.599 30.158,1.796C32.777,2.993 34.963,4.587 36.715,6.576C38.468,8.566 39.787,10.804 40.672,13.291C41.557,15.778 42,18.329 42,20.945C42,23.561 41.557,26.121 40.672,28.626C39.787,31.132 38.468,33.388 36.715,35.396C34.963,37.404 32.777,39.007 30.158,40.204C27.539,41.401 24.495,42 21.028,42ZM21.028,33.434C23.426,33.434 25.445,32.826 27.087,31.611C28.729,30.395 29.964,28.838 30.794,26.941C31.625,25.043 32.04,23.045 32.04,20.945C32.04,18.882 31.625,16.901 30.794,15.004C29.964,13.107 28.729,11.55 27.087,10.334C25.445,9.118 23.426,8.511 21.028,8.511C18.593,8.511 16.555,9.118 14.913,10.334C13.271,11.55 12.045,13.107 11.233,15.004C10.422,16.901 10.016,18.882 10.016,20.945C10.016,23.045 10.422,25.043 11.233,26.941C12.045,28.838 13.271,30.395 14.913,31.611C16.555,32.826 18.593,33.434 21.028,33.434Z" style="fill:white;fill-rule:nonzero;"/>
-                                <path id="Shape2" serif:id="Shape" d="M45,42L45,1L62.633,1C66.06,1 68.916,1.665 71.201,2.995C73.486,4.324 75.19,6.042 76.314,8.147C77.438,10.253 78,12.45 78,14.741C78,17.068 77.438,19.284 76.314,21.389C75.19,23.495 73.486,25.221 71.201,26.57C68.916,27.918 66.06,28.592 62.633,28.592L54.563,28.592L54.563,42L45,42ZM62.578,9.366L54.563,9.366L54.563,20.281L62.578,20.281C64.531,20.281 65.987,19.709 66.945,18.564C67.903,17.418 68.382,16.163 68.382,14.796C68.382,13.429 67.903,12.183 66.945,11.056C65.987,9.93 64.531,9.366 62.578,9.366Z" style="fill:white;fill-rule:nonzero;"/>
-                                <path id="Path3" serif:id="Path" d="M80,42L80,1L108.725,1L108.725,9.311L89.502,9.311L89.502,17.234L106.254,17.234L106.254,25.157L89.502,25.157L89.502,33.689L109,33.689L109,42L80,42Z" style="fill:white;fill-rule:nonzero;"/>
-                                <path id="Path4" serif:id="Path" d="M112,42L112,1L120.89,1L137.439,25.434L137.439,1L147,1L147,42L138.054,42L121.617,18.508L121.617,42L112,42Z" style="fill:white;fill-rule:nonzero;"/>
-                            </g>
-                        </g>
-                        <g id="Emblem---Mono" serif:id="Emblem-/-Mono">
-                            <path id="Emblem-Colour" d="M32.184,0L44.777,6.995L44.777,19.004L54.403,25.133L64.367,19.6L76.961,26.595L76.961,40.605L64.367,47.6L54.349,42.036L44.777,47.748L44.777,71.056L22.388,84L0,71.033L0,45.144L22.388,32.2L43.297,44.288L51.773,39.231L51.773,27.872L42.753,22.129L32.184,28L19.59,21.005L19.59,6.995L32.184,0ZM22.388,36.327L3.582,47.208L3.582,68.969L22.388,79.85L41.195,68.969L41.195,47.208L22.388,36.327ZM64.367,23.606L55.372,28.608L55.372,38.613L64.367,43.616L73.362,38.613L73.362,28.608L64.367,23.606ZM32.184,3.985L23.189,8.987L23.189,18.992L32.184,23.994L41.179,18.992L41.179,8.987L32.184,3.985Z" style="fill:white;fill-rule:nonzero;"/>
-                        </g>
-                    </g>
-                </g>
-            </g>
-        </g>
-    </g>
-    <g id="icon_sire.svg" transform="matrix(5.62365,0.0157307,-0.0157307,5.62365,1121.11,1089.84)">
-        <g transform="matrix(1,0,0,1,-128,-128)">
-            <g id="Images1" serif:id="Images">
-                <g id="obs-logo-sire">
-                    <g id="icon-sire">
-                        <path id="Path5" serif:id="Path" d="M30.94,6.216L30.94,12.041C30.104,12.523 29.696,13.507 29.946,14.44C30.196,15.372 31.041,16.021 32.006,16.021C32.972,16.021 33.817,15.372 34.067,14.44C34.316,13.507 33.909,12.523 33.073,12.041L33.073,6.216C34.542,5.696 35.423,4.194 35.16,2.658C34.896,1.123 33.565,0 32.006,0C30.448,0 29.117,1.123 28.853,2.658C28.59,4.194 29.471,5.696 30.94,6.216Z" style="fill:white;fill-rule:nonzero;"/>
-                        <path id="Path6" serif:id="Path" d="M33.073,57.797L33.073,51.972C33.909,51.489 34.316,50.505 34.067,49.573C33.817,48.641 32.972,47.992 32.006,47.992C31.041,47.992 30.196,48.641 29.946,49.573C29.696,50.505 30.104,51.489 30.94,51.972L30.94,57.797C29.471,58.316 28.59,59.819 28.853,61.354C29.117,62.89 30.448,64.013 32.006,64.013C33.565,64.013 34.896,62.89 35.16,61.354C35.423,59.819 34.542,58.316 33.073,57.797Z" style="fill:white;fill-rule:nonzero;"/>
-                        <path id="Path7" serif:id="Path" d="M60.8,28.807C59.448,28.809 58.245,29.664 57.797,30.94L46.936,30.94L46.936,26.523C46.144,26.318 45.428,25.888 44.875,25.286L36.142,29.943C36.225,30.269 36.269,30.604 36.272,30.94C36.265,32.879 34.95,34.569 33.073,35.054L33.073,46.021C33.865,46.226 34.581,46.656 35.134,47.259L43.867,42.6C43.784,42.275 43.741,41.94 43.737,41.604C43.744,39.665 45.059,37.975 46.936,37.49L46.936,33.073L57.797,33.073C58.342,34.603 59.948,35.48 61.53,35.112C63.112,34.744 64.165,33.247 63.979,31.634C63.792,30.02 62.424,28.804 60.8,28.807Z" style="fill:white;fill-rule:nonzero;"/>
-                        <path id="Path8" serif:id="Path" d="M28.878,28.061C29.678,27.177 30.814,26.673 32.006,26.673C33.198,26.673 34.334,27.177 35.134,28.061L43.867,23.404C43.694,22.751 43.694,22.064 43.867,21.41L35.134,16.756C34.334,17.64 33.198,18.144 32.006,18.144C30.814,18.144 29.677,17.64 28.877,16.756L20.145,21.414C20.319,22.067 20.319,22.754 20.145,23.407L28.878,28.061Z" style="fill:white;fill-rule:nonzero;"/>
-                        <circle id="Oval" cx="48.003" cy="22.408" r="2.133" style="fill:white;"/>
-                        <circle id="Oval1" serif:id="Oval" cx="32.006" cy="30.94" r="2.133" style="fill:white;"/>
-                        <circle id="Oval2" serif:id="Oval" cx="16.01" cy="22.408" r="2.133" style="fill:white;"/>
-                        <path id="Path9" serif:id="Path" d="M28.878,47.256C29.432,46.655 30.148,46.226 30.94,46.021L30.94,35.054C29.852,34.789 28.915,34.099 28.339,33.139C27.762,32.179 27.594,31.028 27.871,29.943L19.139,25.288C18.585,25.89 17.868,26.318 17.076,26.523L17.076,30.94L6.216,30.94C5.696,29.471 4.194,28.59 2.658,28.853C1.123,29.117 0,30.448 0,32.006C0,33.565 1.123,34.896 2.658,35.16C4.194,35.423 5.696,34.542 6.216,33.073L17.076,33.073L17.076,37.49C18.164,37.755 19.101,38.445 19.678,39.405C20.254,40.365 20.423,41.516 20.145,42.601L28.878,47.256Z" style="fill:white;fill-rule:nonzero;"/>
-                        <circle id="Oval3" serif:id="Oval" cx="48.003" cy="41.604" r="2.133" style="fill:white;"/>
-                        <circle id="Oval4" serif:id="Oval" cx="16.01" cy="41.604" r="2.133" style="fill:white;"/>
-                    </g>
-                </g>
-            </g>
-        </g>
-    </g>
-    <g transform="matrix(13.7804,0,0,13.7804,-10351.2,-6039.82)">
-        <g transform="matrix(23.0274,0,0,23.0274,809.532,486.834)">
-            <path d="M0.675,-0.229C0.675,-0.157 0.644,-0.099 0.584,-0.054C0.523,-0.009 0.441,0.013 0.336,0.013C0.276,0.013 0.224,0.008 0.179,-0.003C0.134,-0.013 0.092,-0.027 0.053,-0.043L0.053,-0.217L0.074,-0.217C0.112,-0.186 0.156,-0.163 0.204,-0.146C0.252,-0.129 0.298,-0.121 0.342,-0.121C0.354,-0.121 0.369,-0.122 0.387,-0.124C0.406,-0.126 0.421,-0.129 0.433,-0.134C0.447,-0.14 0.459,-0.147 0.468,-0.156C0.477,-0.165 0.482,-0.178 0.482,-0.195C0.482,-0.211 0.475,-0.225 0.462,-0.236C0.448,-0.248 0.428,-0.257 0.402,-0.263C0.375,-0.269 0.346,-0.275 0.316,-0.281C0.285,-0.287 0.257,-0.294 0.23,-0.303C0.169,-0.323 0.125,-0.35 0.098,-0.384C0.071,-0.418 0.058,-0.46 0.058,-0.51C0.058,-0.578 0.088,-0.633 0.149,-0.676C0.209,-0.719 0.287,-0.74 0.383,-0.74C0.431,-0.74 0.478,-0.736 0.525,-0.726C0.571,-0.717 0.612,-0.705 0.646,-0.691L0.646,-0.524L0.626,-0.524C0.597,-0.547 0.561,-0.567 0.518,-0.583C0.476,-0.599 0.432,-0.606 0.388,-0.606C0.373,-0.606 0.357,-0.605 0.342,-0.603C0.326,-0.601 0.311,-0.597 0.297,-0.591C0.284,-0.586 0.273,-0.579 0.264,-0.569C0.255,-0.559 0.25,-0.548 0.25,-0.535C0.25,-0.516 0.258,-0.501 0.272,-0.491C0.287,-0.481 0.315,-0.471 0.355,-0.463C0.382,-0.457 0.408,-0.452 0.432,-0.447C0.457,-0.442 0.483,-0.434 0.512,-0.425C0.567,-0.407 0.608,-0.382 0.635,-0.351C0.662,-0.319 0.675,-0.279 0.675,-0.229Z" style="fill:white;fill-rule:nonzero;"/>
-        </g>
-        <g transform="matrix(23.0274,0,0,23.0274,825.892,486.834)">
-            <path d="M0.486,-0L0.06,-0L0.06,-0.129L0.179,-0.129L0.179,-0.598L0.06,-0.598L0.06,-0.727L0.486,-0.727L0.486,-0.598L0.367,-0.598L0.367,-0.129L0.486,-0.129L0.486,-0Z" style="fill:white;fill-rule:nonzero;"/>
-        </g>
-        <g transform="matrix(23.0274,0,0,23.0274,838.462,486.834)">
-            <path d="M0.5,-0.504C0.5,-0.523 0.497,-0.538 0.489,-0.551C0.482,-0.564 0.469,-0.575 0.451,-0.582C0.438,-0.587 0.423,-0.59 0.406,-0.592C0.389,-0.593 0.37,-0.593 0.347,-0.593L0.279,-0.593L0.279,-0.397L0.337,-0.397C0.367,-0.397 0.392,-0.399 0.412,-0.402C0.432,-0.405 0.449,-0.411 0.463,-0.422C0.476,-0.432 0.485,-0.443 0.491,-0.455C0.497,-0.468 0.5,-0.484 0.5,-0.504ZM0.793,-0L0.564,-0L0.366,-0.267L0.279,-0.267L0.279,-0L0.093,-0L0.093,-0.727L0.407,-0.727C0.45,-0.727 0.487,-0.725 0.518,-0.72C0.549,-0.715 0.578,-0.704 0.605,-0.688C0.632,-0.672 0.654,-0.651 0.67,-0.625C0.686,-0.599 0.694,-0.566 0.694,-0.527C0.694,-0.474 0.682,-0.43 0.657,-0.396C0.632,-0.362 0.597,-0.334 0.55,-0.312L0.793,-0Z" style="fill:white;fill-rule:nonzero;"/>
-        </g>
-        <g transform="matrix(23.0274,0,0,23.0274,856.475,486.834)">
-            <path d="M0.619,-0L0.093,-0L0.093,-0.727L0.619,-0.727L0.619,-0.586L0.279,-0.586L0.279,-0.461L0.594,-0.461L0.594,-0.32L0.279,-0.32L0.279,-0.141L0.619,-0.141L0.619,-0Z" style="fill:white;fill-rule:nonzero;"/>
-        </g>
-    </g>
+    <use xlink:href="#_Image1" x="3.888" y="0" width="2044.11px" height="728.488px" transform="matrix(0.999566,0,0,0.999298,0,0)"/>
+    <defs>
+        <image id="_Image1" width="2045px" height="729px" xlink:href="data:image/png;base64,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"/>
+    </defs>
 </svg>
diff --git a/doc/source/install.rst b/doc/source/install.rst
index 29c90c979..13d3ffac0 100644
--- a/doc/source/install.rst
+++ b/doc/source/install.rst
@@ -3,15 +3,15 @@ Installation
 ============
 
 Binary packages for :mod:`sire` are available on MacOS, Linux and Windows
-running on Intel (X86-64) or ARM64 processors.
+running on Intel/AMD (X86-64) or ARM64 processors.
 
 :mod:`sire` can be compiled on any UNIX or Windows-compatible operating system
 running on X86-64, ARM64 or PowerPC processors.
 
 You have a range of options for installing the software.
 
-No-installation - Run in a Web Browser
-======================================
+1. No-installation - Run in a Web Browser
+=========================================
 
 We run a completely free `JupyterHub <https://try.openbiosim.org>`__ on
 which we have sire installed.
@@ -45,8 +45,8 @@ to learn how to use :mod:`sire` or the
    use this service to explore and learn :mod:`sire`.
    Do not use it for production work.
 
-Easy installation - Run in a conda environment
-==============================================
+2. Easy installation - Run in a conda environment
+=================================================
 
 The easiest way to install :mod:`sire` is in a new
 `conda environment <https://anaconda.org>`__.
@@ -57,8 +57,9 @@ as this is pre-configured to use `conda-forge <https://conda-forge.org>`__,
 and bundles `mamba <https://mamba.readthedocs.io/en/latest/>`__, which
 is a fast drop-in replacement for `conda <https://conda.io>`__.
 
-Option 1. Installing a new copy of ``mambaforge``
--------------------------------------------------
+.. _Install_Mambaforge:
+Either... Install a new copy of ``mambaforge``
+----------------------------------------------
 
 To install a new copy of
 `mambaforge <https://github.com/conda-forge/miniforge#mambaforge>`__,
@@ -73,8 +74,8 @@ Once installed, you should be able to run the ``mamba`` command to
 install other packages (e.g. ``mamba -h`` will print out help on
 how to use the ``mamba`` command).
 
-Option 2. Using an existing anaconda/miniconda install
-------------------------------------------------------
+Or... Use an existing anaconda/miniconda install
+------------------------------------------------
 
 If you want to use an existing anaconda or miniconda installation,
 then first open a terminal with that distribution activated.
@@ -94,14 +95,15 @@ drop-in replacement for ``conda``, so first install ``mamba``.
 
 This should install mamba. If this fails, then your anaconda or miniconda
 environment is likely quite full, or else it is outdated. We recommend
-going back to Option 1 and installing a new copy of ``mambaforge``.
+going back and following `the instructions <_Install_Mambaforge>`
+to install a new copy of ``mambaforge``.
 
 If this works, then you should now be able to run the ``mamba`` command
 to install other packages (e.g. ``mamba -h`` will print out help
 on how to use the ``mamba`` command).
 
-Installing sire into a new environment
---------------------------------------
+And then... Install sire into a new environment
+-----------------------------------------------
 
 We recommend that :mod:`sire` is installed into a new (clean) environment.
 This minimises the risk of failures caused by incompatible dependencies.
@@ -162,8 +164,8 @@ We encourage you to take a look at :doc:`the tutorial <tutorial/index>`
 to learn how to use :mod:`sire` or the
 :doc:`quickstart guide <quickstart/index>` if you want an overview.
 
-Also easy installation - Run in a container
-===========================================
+3. Also easy installation - Run in a container
+==============================================
 
 Another route to install :mod:`sire` is to download and run our
 pre-built containers. These can be run via
@@ -219,8 +221,8 @@ We encourage you to take a look at :doc:`the tutorial <tutorial/index>`
 to learn how to use :mod:`sire` or the
 :doc:`quickstart guide <quickstart/index>` if you want an overview.
 
-Harder installation - Compile from source
-=========================================
+4. Harder installation - Compile from source
+============================================
 
 Sometimes you will want to compile and run :mod:`sire` from source.
 This could be because we don't distribute a binary package for your
@@ -230,7 +232,7 @@ branch if you are a developer).
 
 You compile :mod:`sire` into an existing anaconda / miniconda environment.
 Please create and activate an environment, e.g. by following
-the "Option 1" instructions to install a fresh ``mambaforge`` and
+`the instructions <_Install_Mambaforge>` to install a fresh ``mambaforge`` and
 then creating and activating Python 3.9 environment called
 ``openbiosim``.
 
diff --git a/docker/sire-generate-wrappers/README.md b/docker/sire-generate-wrappers/README.md
index ffc280b62..5a2d7547e 100644
--- a/docker/sire-generate-wrappers/README.md
+++ b/docker/sire-generate-wrappers/README.md
@@ -1,9 +1,9 @@
 # Generating the Python wrappers
 
 This is a container that is used to consistently generate
-the Python wrappers for Sire. The container has a working
+the Python wrappers for sire. The container has a working
 version of Py++ in a miniconda that also has all of the header
-files that are needed for Sire.
+files that are needed for sire.
 
 ## Running the container
 
@@ -11,16 +11,24 @@ The simplest way to start is to run the container that we've
 made already. Do this by typing;
 
 ```
-docker run -it siremol/sire-generate-wrappers
+$ docker run -it openbiosim/sire-generate-wrappers:x86
+```
+
+on Intel/AMD (X86-64) systems, and
+
+```
+$ docker run -it openbiosim/sire-generate-wrappers:arm64
 ```
 
+on Apple / ARM64 systems.
+
 Assuming you have docker installed and working, this should
 pull the container from docker hub, and then start a bash
 prompt in that container. You should see something like
 this;
 
 ```
-Unable to find image 'siremol/sire-generate-wrappers:latest' locally
+Unable to find image 'openbiosim/sire-generate-wrappers:arm64' locally
 Trying to pull repository docker.io/siremol/sire-generate-wrappers ...
 latest: Pulling from docker.io/siremol/sire-generate-wrappers
 a2abf6c4d29d: Pull complete
@@ -41,7 +49,7 @@ Status: Downloaded newer image for siremol/sire-generate-wrappers:latest
 
 ## Generating the wrappers
 
-You generate the wrappers for your chosen branch of Sire by typing;
+You generate the wrappers for your chosen branch of sire by typing;
 
 ```
 (base) root:~# generate_wrappers --branch {BRANCH_NAME}
@@ -61,7 +69,7 @@ a long time!
 ## Checking the wrappers
 
 The `generate_wrappers` command will check out your branch
-to the folder `$HOME/Sire`. Feel free to explore this
+to the folder `$HOME/sire`. Feel free to explore this
 folder and run commands manually if there are any problems.
 
 You can check which wrappers were changed by running
@@ -81,7 +89,7 @@ where `${YOUR NAME}` is your real name, as on GitHub, and
 these in double quotes.
 
 This will use `git config` to set those values, before
-running `git add` in `$HOME/Sire`, and then running
+running `git add` in `$HOME/sire`, and then running
 `git commit` and `git push`.
 
 The `git push` command will ask you for your GitHub
@@ -90,21 +98,27 @@ be pushed if these are entered and are correct.
 
 Assuming everything has worked, then congratulations!
 You have successfully generated and pushed your new
-Sire Python wrappers.
+sire Python wrappers.
 
-## Using the container against an external Sire directory
+## Using the container against an external sire directory
 
 You may wish to use this container to create wrappers for
-a Sire directory on your computer. To do this, you can mount
-the Sire directory into the container via
+a sire directory on your computer. To do this, you can mount
+the sire directory into the container via
+
+```
+docker run -it -v /path/to/sire:/root/sire openbiosim/sire-generate-wrappers:x86
+```
+
+or
 
 ```
-docker run -it -v /path/to/Sire:/root/Sire siremol/sire-generate-wrappers
+docker run -it -v /path/to/sire:/root/sire openbiosim/sire-generate-wrappers:arm64
 ```
 
-This will make your Sire directory (in `/path/to/Sire`) available in the
-container as `/root/Sire`. You can now generate wrappers in the
-container that will write directly to your real local Sire directory
+This will make your sire directory (in `/path/to/sire`) available in the
+container as `/root/sire`. You can now generate wrappers in the
+container that will write directly to your real local sire directory
 (and so can be compiled, tested and pushed to GitHub from there).
 
 Once in the container, you need to run `unpack_headers` to unpack the
@@ -114,14 +128,14 @@ headers.
 (base) root:~# unpack_headers
 ```
 
-You can now change into the Sire directory and generate wrappers as you
+You can now change into the sire directory and generate wrappers as you
 need, e.g.
 
 ```
-(base) root:~# cd Sire/wrapper
-(base) root:~/Sire/wrapper# python AutoGenerate/scanheaders.py ~/Sire/corelib/src/libs/ .
-(base) root:~/Sire/wrapper# cd Search
-(base) root:~/Sire/wrapper/Search# python ../AutoGenerate/create_wrappers.py
+(base) root:~# cd sire/wrapper
+(base) root:~/sire/wrapper# python AutoGenerate/scanheaders.py ~/sire/corelib/src/libs/ .
+(base) root:~/sire/wrapper# cd Search
+(base) root:~/sire/wrapper/Search# python ../AutoGenerate/create_wrappers.py
 ```
 
 would regenerate the wrappers for the `Search` module. Note that this
@@ -132,26 +146,26 @@ you needing to push and pull changes via git.
 
 Be very careful doing this, as the git version in the container is not
 going to be the same as on your local computer. Also be careful not
-to run `generate_wrappers` as this will delete your local Sire container.
+to run `generate_wrappers` as this will delete your local sire container.
 
 ## Creating the sire-generate-wrappers container
 
 You only need to read here if you want to create the
 sire-generate-wrappers container yourself.
 
-First, you must have a working installation on Sire
+First, you must have a working installation on sire
 on your computer. This is needed so that we can
 copy the header files from this installation into
-the container. We will assume that Sire is installed
+the container. We will assume that sire is installed
 in `$HOME/sire.app`.
 
 Next, you must navigate to this directory, e.g.
 
 ```
-cd $HOME/Sire/docker/sire-generate-wrappers
+cd $HOME/sire/docker/sire-generate-wrappers
 ```
 
-(assuming Sire was cloned to `$HOME/Sire`)
+(assuming sire was cloned to `$HOME/sire`)
 
 Create the `includes.tar.bz2` file by running the
 `create_includes_tarball` script via;
diff --git a/setup.py b/setup.py
index 83a8c99ca..a974e2e48 100644
--- a/setup.py
+++ b/setup.py
@@ -27,6 +27,15 @@
 import shutil
 import glob
 
+try:
+    # Find out how much memory we have in total.
+    # The wrappers need 4 GB per core to compile
+    import psutil
+
+    total_memory_gb = psutil.virtual_memory()[0] / (1024 * 1024 * 1024)
+except Exception:
+    total_memory_gb = None
+
 # Debug - we need to print out all of the environment variables
 # for key, value in os.environ.items():
 #     print(f"{key}\n{value}\n")
@@ -43,7 +52,7 @@
 sys.path.insert(0, os.path.join(curdir, "actions"))
 
 # We need to verify that this is a Python that is part of a
-# conda installation
+# conda installation
 
 # Find the path to the conda or mamba executable
 conda_base = os.path.abspath(os.path.dirname(sys.executable))
@@ -79,9 +88,11 @@
     if conda is None:
         conda = os.path.join(conda_bin, "conda")
 else:
-    print("Cannot find a 'python' binary in directory '%s'. "
-          "Are you running this script using the python executable "
-          "from a valid miniconda or anaconda installation?" % conda_base)
+    print(
+        "Cannot find a 'python' binary in directory '%s'. "
+        "Are you running this script using the python executable "
+        "from a valid miniconda or anaconda installation?" % conda_base
+    )
     sys.exit(-1)
 
 
@@ -136,53 +147,109 @@ def find_mamba():
 def parse_args():
     import argparse
     import multiprocessing
-    parser=argparse.ArgumentParser()
+
+    parser = argparse.ArgumentParser()
 
     ncores = multiprocessing.cpu_count()
 
-    if ncores % 2 == 0:
-        npycores = int(ncores / 2)
+    if total_memory_gb is None:
+        # it is safest to half the number of python build cores
+        if ncores % 2 == 0:
+            npycores = int(ncores / 2)
+        else:
+            npycores = int((ncores + 1) / 2)
     else:
-        npycores = int((ncores + 1) / 2)
-
-    parser.add_argument("-C", "--corelib", action="append", nargs=1,
-        metavar=("PARAMETER=VALUE",), default=[],
-        help="pass CMake definitions for corelib")
-    parser.add_argument("-W", "--wrapper", action="append", nargs=1,
-        metavar=("PARAMETER=VALUE",), default=[],
-        help="pass CMake definitions for wrapper")
-    parser.add_argument("-G", "--generator", action="append", nargs=1,
-        metavar=("GENERATOR",), default=[],
-        help="pass CMake generator")
-    parser.add_argument("-n", "--ncores", action="store", type=int, nargs=1,
-        metavar=("N_CORES",), default=[ncores],
+        # we need at least 4 GB RAM per core
+        npycores = min(ncores, int(total_memory_gb / 4))
+
+        if npycores < 1:
+            npycores = 1
+
+    parser.add_argument(
+        "-C",
+        "--corelib",
+        action="append",
+        nargs=1,
+        metavar=("PARAMETER=VALUE",),
+        default=[],
+        help="pass CMake definitions for corelib",
+    )
+    parser.add_argument(
+        "-W",
+        "--wrapper",
+        action="append",
+        nargs=1,
+        metavar=("PARAMETER=VALUE",),
+        default=[],
+        help="pass CMake definitions for wrapper",
+    )
+    parser.add_argument(
+        "-G",
+        "--generator",
+        action="append",
+        nargs=1,
+        metavar=("GENERATOR",),
+        default=[],
+        help="pass CMake generator",
+    )
+    parser.add_argument(
+        "-n",
+        "--ncores",
+        action="store",
+        type=int,
+        nargs=1,
+        metavar=("N_CORES",),
+        default=[ncores],
         help="Number of CPU cores used for compiling corelib "
-        "(defaults to all available on the current system)")
-    parser.add_argument("-N", "--npycores", action="store", type=int, nargs=1,
-        metavar=("N_PYTHON_CORES",), default=[npycores],
+        "(defaults to all available on the current system)",
+    )
+    parser.add_argument(
+        "-N",
+        "--npycores",
+        action="store",
+        type=int,
+        nargs=1,
+        metavar=("N_PYTHON_CORES",),
+        default=[npycores],
         help="Number of CPU cores used for compiling Python wrappers "
-        "(defaults to the number of CPU cores used for compiling corelib)")
-    parser.add_argument("--install-bss-deps", action="store_true", default=False,
+        "(defaults to the number of CPU cores used for compiling corelib)",
+    )
+    parser.add_argument(
+        "--install-bss-deps",
+        action="store_true",
+        default=False,
         help="Install BioSimSpace's dependencies too. This helps ensure "
-             "compatibility between Sire's and BioSimSpace's dependencies.")
-    parser.add_argument("--skip-deps", action="store_true", default=False,
+        "compatibility between Sire's and BioSimSpace's dependencies.",
+    )
+    parser.add_argument(
+        "--skip-deps",
+        action="store_true",
+        default=False,
         help="Skip the installation of the dependencies (only use if you know "
-             "that they are already installed)")
-    parser.add_argument("--skip-build", action="store_true", default=False,
+        "that they are already installed)",
+    )
+    parser.add_argument(
+        "--skip-build",
+        action="store_true",
+        default=False,
         help="Skip the build of the C++ code (only use if you know that "
-             "the C++ code is already built)")
-    parser.add_argument("action", nargs="*",
+        "the C++ code is already built)",
+    )
+    parser.add_argument(
+        "action",
+        nargs="*",
         help="Should be one of 'install_requires', 'build', 'install' or 'install_module'.\n"
-             "\n [install_requires] : Just install the conda dependencies.\n"
-             " [build] : 'install_requires' plus compile and install corelib, and just compile the wrappers.\n"
-             " [install] : 'build' plus install the wrappers and install the module.\n"
-             " [install_module] : Just install the module (no compilation or conda dependencies)."
-             )
+        "\n [install_requires] : Just install the conda dependencies.\n"
+        " [build] : 'install_requires' plus compile and install corelib, and just compile the wrappers.\n"
+        " [install] : 'build' plus install the wrappers and install the module.\n"
+        " [install_module] : Just install the module (no compilation or conda dependencies).",
+    )
     return parser.parse_args()
 
 
 _installed_deps = None
 
+
 def _get_installed(conda: str):
     """Return the list of installed conda dependencies"""
     global _installed_deps
@@ -215,6 +282,7 @@ def _add_to_dependencies(dependencies, lines):
 
 _is_conda_prepped = False
 
+
 def conda_install(dependencies, install_bss_reqs=False):
     """Install the passed list of dependencies using conda"""
 
@@ -224,7 +292,9 @@ def conda_install(dependencies, install_bss_reqs=False):
 
     if not _is_conda_prepped:
         if install_bss_reqs:
-            cmd = "%s config --prepend channels openbiosim/label/dev" % conda_exe
+            cmd = (
+                "%s config --prepend channels openbiosim/label/dev" % conda_exe
+            )
             print("Activating openbiosim channel channel using: '%s'" % cmd)
             status = subprocess.run(cmd.split())
             if status.returncode != 0:
@@ -253,7 +323,7 @@ def conda_install(dependencies, install_bss_reqs=False):
     else:
         conda_install = [mamba, "install", "--yes"]
 
-    dependencies = [f"\"{dep}\"" for dep in dependencies]
+    dependencies = [f'"{dep}"' for dep in dependencies]
 
     cmd = [*conda_install, *dependencies]
     print("\nInstalling packages using: '%s'" % " ".join(cmd))
@@ -277,16 +347,20 @@ def conda_install(dependencies, install_bss_reqs=False):
 
 def install_requires(install_bss_reqs=False):
     """Installs all of the dependencies. This can safely be called
-       multiple times, as it will cache the result to prevent future
-       installs taking too long
+    multiple times, as it will cache the result to prevent future
+    installs taking too long
     """
     print(f"Installing requirements for {platform_string}")
 
     if not os.path.exists(conda):
-        print("\nSire can only be installed into a conda or miniconda environment.")
-        print("Please install conda, miniconda, miniforge or similar, then "
-              "activate the conda environment, then rerun this installation "
-              "script.")
+        print(
+            "\nSire can only be installed into a conda or miniconda environment."
+        )
+        print(
+            "Please install conda, miniconda, miniforge or similar, then "
+            "activate the conda environment, then rerun this installation "
+            "script."
+        )
         sys.exit(-1)
 
     # install mamba if it doesn't exist already
@@ -308,7 +382,9 @@ def install_requires(install_bss_reqs=False):
             from parse_requirements import parse_requirements
         except ImportError as e:
             print("\n\n[ERROR] ** You need to install pip-requirements-parser")
-            print("Run `conda install -c conda-forge pip-requirements-parser\n\n")
+            print(
+                "Run `conda install -c conda-forge pip-requirements-parser\n\n"
+            )
             raise e
 
     reqs = parse_requirements("requirements.txt")
@@ -323,27 +399,32 @@ def install_requires(install_bss_reqs=False):
 
 
 def add_default_cmake_defs(cmake_defs, ncores):
-    for a in ("ANACONDA_BASE=%s" % conda_base.replace("\\", "/"),
-              "BUILD_NCORES=%s" % ncores):
+    for a in (
+        "ANACONDA_BASE=%s" % conda_base.replace("\\", "/"),
+        "BUILD_NCORES=%s" % ncores,
+    ):
         found = False
         for d in cmake_defs:
-            if (a in d[0]):
+            if a in d[0]:
                 found = True
                 break
-        if (not found):
+        if not found:
             cmake_defs.append([a])
 
     if is_macos:
-        # don't compile with AVX as the resulting binaries won't
+        # don't compile with AVX as the resulting binaries won't
         # work on M1 macs
         cmake_defs.append(["SIRE_DISABLE_AVX=ON"])
         cmake_defs.append(["SIRE_DISABLE_AVX512F=ON"])
 
 
-def make_cmd(ncores, install = False):
+def make_cmd(ncores, install=False):
     if is_windows:
         action = "INSTALL" if install else "ALL_BUILD"
-        make_args = "%s -- /m:%s /p:Configuration=Release /p:Platform=x64" % (action, ncores)
+        make_args = "%s -- /m:%s /p:Configuration=Release /p:Platform=x64" % (
+            action,
+            ncores,
+        )
     else:
         action = "install" if install else "all"
         make_args = "%s -- VERBOSE=1 -j %s" % (action, ncores)
@@ -360,7 +441,10 @@ def _get_build_ext():
         else:
             ext = ""
 
-        return os.path.basename(conda_base.replace(" ", "_").replace(".", "_")) + ext
+        return (
+            os.path.basename(conda_base.replace(" ", "_").replace(".", "_"))
+            + ext
+        )
 
 
 def _get_bin_dir():
@@ -375,12 +459,11 @@ def _get_bin_dir():
         return conda_bin
 
 
-def build(ncores: int = 1, npycores: int = 1,
-          coredefs=[], pydefs=[]):
+def build(ncores: int = 1, npycores: int = 1, coredefs=[], pydefs=[]):
     print("\nCompiling the C++ code")
 
-    CC=None
-    CXX=None
+    CC = None
+    CXX = None
 
     cmake = "cmake"
 
@@ -410,8 +493,12 @@ def build(ncores: int = 1, npycores: int = 1,
         print(f"{CC} => {CC_bin}")
 
         if CXX_bin is None or CC_bin is None:
-            print("Cannot find the compilers requested by conda-build in the PATH")
-            print("Please check that the compilers are installed and available.")
+            print(
+                "Cannot find the compilers requested by conda-build in the PATH"
+            )
+            print(
+                "Please check that the compilers are installed and available."
+            )
             sys.exit(-1)
 
         # use the full paths, in case CMake struggles
@@ -481,29 +568,36 @@ def build(ncores: int = 1, npycores: int = 1,
         status = subprocess.run([cmake, "."])
     else:
         # this is the first time we are running cmake
-        sourcedir = os.path.join(os.path.dirname(os.path.dirname(
-            os.getcwd())), "corelib")
+        sourcedir = os.path.join(
+            os.path.dirname(os.path.dirname(os.getcwd())), "corelib"
+        )
 
         if not os.path.exists(os.path.join(sourcedir, "CMakeLists.txt")):
-            print("SOMETHING IS WRONG. There is no file %s" % os.path.join(sourcedir, "CMakeLists.txt"))
+            print(
+                "SOMETHING IS WRONG. There is no file %s"
+                % os.path.join(sourcedir, "CMakeLists.txt")
+            )
             sys.exit(-1)
 
         for a in ("NetCDF_ROOT_DIR", "OPENMM_ROOT_DIR"):
             for i, d in enumerate(args.corelib):
-                if (a in d[0]):
+                if a in d[0]:
                     v = args.corelib.pop(i)[0]
-                    if (not a in os.environ):
+                    if not a in os.environ:
                         os.environ[a] = v.split("=")[-1]
 
         add_default_cmake_defs(args.corelib, ncores)
 
-        cmake_cmd = [cmake, *sum([["-D", d[0]] for d in args.corelib], []),
-                     *sum([["-G", g[0]] for g in args.generator], []),
-                     sourcedir]
+        cmake_cmd = [
+            cmake,
+            *sum([["-D", d[0]] for d in args.corelib], []),
+            *sum([["-G", g[0]] for g in args.generator], []),
+            sourcedir,
+        ]
 
-        if (CC):
+        if CC:
             os.environ["CC"] = CC
-        if (CXX):
+        if CXX:
             os.environ["CXX"] = CXX
 
         print(" ".join(cmake_cmd))
@@ -535,7 +629,9 @@ def build(ncores: int = 1, npycores: int = 1,
     # Compile and install, as need to install to compile the wrappers
     make_args = make_cmd(ncores, True)
 
-    print("NOW RUNNING \"%s\" --build . --target %s" % (cmake, " ".join(make_args)))
+    print(
+        'NOW RUNNING "%s" --build . --target %s' % (cmake, " ".join(make_args))
+    )
     sys.stdout.flush()
     status = subprocess.run([cmake, "--build", ".", "--target", *make_args])
 
@@ -568,18 +664,25 @@ def build(ncores: int = 1, npycores: int = 1,
         status = subprocess.run([cmake, "."])
     else:
         # this is the first time we are running cmake
-        sourcedir = os.path.join(os.path.dirname(os.path.dirname(
-                                                 os.getcwd())), "wrapper")
+        sourcedir = os.path.join(
+            os.path.dirname(os.path.dirname(os.getcwd())), "wrapper"
+        )
 
         if not os.path.exists(os.path.join(sourcedir, "CMakeLists.txt")):
-            print("SOMETHING IS WRONG. There is no file %s" % os.path.join(sourcedir, "CMakeLists.txt"))
+            print(
+                "SOMETHING IS WRONG. There is no file %s"
+                % os.path.join(sourcedir, "CMakeLists.txt")
+            )
             sys.exit(-1)
 
         add_default_cmake_defs(args.wrapper, npycores)
 
-        cmake_cmd = [cmake, *sum([["-D", d[0]] for d in args.wrapper], []),
-                     *sum([["-G", g[0]] for g in args.generator], []),
-                     sourcedir]
+        cmake_cmd = [
+            cmake,
+            *sum([["-D", d[0]] for d in args.wrapper], []),
+            *sum([["-G", g[0]] for g in args.generator], []),
+            sourcedir,
+        ]
 
         print(" ".join(cmake_cmd))
         sys.stdout.flush()
@@ -592,7 +695,9 @@ def build(ncores: int = 1, npycores: int = 1,
     # Just compile the wrappers
     make_args = make_cmd(npycores, False)
 
-    print("NOW RUNNING \"%s\" --build . --target %s" % (cmake, " ".join(make_args)))
+    print(
+        'NOW RUNNING "%s" --build . --target %s' % (cmake, " ".join(make_args))
+    )
     sys.stdout.flush()
     status = subprocess.run([cmake, "--build", ".", "--target", *make_args])
 
@@ -636,17 +741,24 @@ def install_module(ncores: int = 1):
         status = subprocess.run([cmake, "."])
     else:
         # this is the first time we are running cmake
-        sourcedir = os.path.join(os.path.dirname(os.path.dirname(
-            os.getcwd())), "src", "sire")
+        sourcedir = os.path.join(
+            os.path.dirname(os.path.dirname(os.getcwd())), "src", "sire"
+        )
 
         if not os.path.exists(os.path.join(sourcedir, "CMakeLists.txt")):
-            print("SOMETHING IS WRONG. There is no file %s" % os.path.join(sourcedir, "CMakeLists.txt"))
+            print(
+                "SOMETHING IS WRONG. There is no file %s"
+                % os.path.join(sourcedir, "CMakeLists.txt")
+            )
             sys.exit(-1)
 
         add_default_cmake_defs(args.wrapper, ncores)
-        cmake_cmd = [cmake, *sum([["-D", d[0]] for d in args.wrapper], []),
-                     *sum([["-G", g[0]] for g in args.generator], []),
-                     sourcedir]
+        cmake_cmd = [
+            cmake,
+            *sum([["-D", d[0]] for d in args.wrapper], []),
+            *sum([["-G", g[0]] for g in args.generator], []),
+            sourcedir,
+        ]
         print(" ".join(cmake_cmd))
         sys.stdout.flush()
         status = subprocess.run(cmake_cmd)
@@ -658,7 +770,9 @@ def install_module(ncores: int = 1):
     make_args = make_cmd(ncores, True)
 
     # Now that cmake has run, we can compile and install wrapper
-    print("NOW RUNNING \"%s\" --build . --target %s" % (cmake, " ".join(make_args)))
+    print(
+        'NOW RUNNING "%s" --build . --target %s' % (cmake, " ".join(make_args))
+    )
     sys.stdout.flush()
     status = subprocess.run([cmake, "--build", ".", "--target", *make_args])
 
@@ -698,7 +812,9 @@ def install(ncores: int = 1, npycores: int = 1):
     # Now install the wrappers
     make_args = make_cmd(npycores, True)
 
-    print("NOW RUNNING \"%s\" --build . --target %s" % (cmake, " ".join(make_args)))
+    print(
+        'NOW RUNNING "%s" --build . --target %s' % (cmake, " ".join(make_args))
+    )
     sys.stdout.flush()
     status = subprocess.run([cmake, "--build", ".", "--target", *make_args])
 
@@ -723,16 +839,22 @@ def install(ncores: int = 1, npycores: int = 1):
     action = args.action[0]
 
     if is_windows and (args.generator is None or len(args.generator) == 0):
-        #args.generator = [["Visual Studio 17 2022"]]
-        args.generator = [["Visual Studio 15 2017 Win64"]]  # preferred VC version for conda
+        # args.generator = [["Visual Studio 17 2022"]]
+        args.generator = [
+            ["Visual Studio 15 2017 Win64"]
+        ]  # preferred VC version for conda
 
     if action == "install":
         if not (args.skip_deps or args.skip_build):
             install_requires(install_bss_reqs=install_bss)
 
         if not args.skip_build:
-            build(ncores=args.ncores[0], npycores=args.npycores[0],
-                  coredefs=args.corelib, pydefs=args.wrapper)
+            build(
+                ncores=args.ncores[0],
+                npycores=args.npycores[0],
+                coredefs=args.corelib,
+                pydefs=args.wrapper,
+            )
 
         install(ncores=args.ncores[0], npycores=args.npycores[0])
 
@@ -740,8 +862,12 @@ def install(ncores: int = 1, npycores: int = 1):
         if not args.skip_deps:
             install_requires(install_bss_reqs=install_bss)
 
-        build(ncores=args.ncores[0], npycores=args.npycores[0],
-              coredefs=args.corelib, pydefs=args.wrapper)
+        build(
+            ncores=args.ncores[0],
+            npycores=args.npycores[0],
+            coredefs=args.corelib,
+            pydefs=args.wrapper,
+        )
 
     elif action == "install_requires":
         install_requires(install_bss_reqs=install_bss)
@@ -750,5 +876,7 @@ def install(ncores: int = 1, npycores: int = 1):
         install_module(ncores=args.ncores[0])
 
     else:
-        print(f"Unrecognised action '{action}'. Please use 'install_requires', "
-              "'build', 'install' or 'install_module'")
+        print(
+            f"Unrecognised action '{action}'. Please use 'install_requires', "
+            "'build', 'install' or 'install_module'"
+        )
diff --git a/src/sire/mol/__init__.py b/src/sire/mol/__init__.py
index 8ce6270ca..749d4eaba 100644
--- a/src/sire/mol/__init__.py
+++ b/src/sire/mol/__init__.py
@@ -1355,7 +1355,9 @@ def _total_energy(obj, other=None, map=None):
     elif other is None:
         return calculate_energy(mols.molecules(), map=map)
     else:
-        return calculate_energy(mols.molecules(), _to_molecules(other), map=map)
+        return calculate_energy(
+            mols.molecules(), _to_molecules(other), map=map
+        )
 
 
 Atom.energy = _atom_energy
@@ -1404,5 +1406,60 @@ def _total_energy(obj, other=None, map=None):
 SelectorM_Segment_.view = _viewfunc
 SelectorM_CutGroup_.view = _viewfunc
 
+if not hasattr(SelectorMol, "__orig__find__"):
+
+    def __find__(obj, views):
+        """
+        Find the index(es) of the passed view(s) in this container.
+        This returns a single index if a single view is passed,
+        or a list of indexes if multiple views are passed
+        (in the same order as the passed views).
+
+        This raises an IndexError if any of the views are
+        not in this container.
+        """
+        matches = obj.__orig__find__(views)
+
+        if matches is None:
+            raise IndexError("Cannot find the passed view in the container.")
+
+        if views.is_selector():
+            if len(matches) != len(views):
+                raise IndexError(
+                    "Could not find all of the passed views "
+                    "in the container. We only found "
+                    f"{len(matches)} of the required "
+                    f"{len(views)}."
+                )
+
+            return matches
+        else:
+            if len(matches) != 1:
+                raise IndexError(
+                    "We matched too many indexes? "
+                    f"{matches}. Only expected to match one?"
+                )
+
+            return matches[0]
+
+    def __fix__find(CLASS):
+        CLASS.__orig__find__ = CLASS.find
+        CLASS.find = __find__
+
+    for C in [
+        Selector_Atom_,
+        Selector_Residue_,
+        Selector_Chain_,
+        Selector_CutGroup_,
+        Selector_Segment_,
+        SelectorMol,
+        SelectorM_Atom_,
+        SelectorM_Residue_,
+        SelectorM_Chain_,
+        SelectorM_CutGroup_,
+        SelectorM_Segment_,
+    ]:
+        __fix__find(C)
+
 # Remove some temporary variables
 del C
diff --git a/src/sire/search/__init__.py b/src/sire/search/__init__.py
index 776a7351a..fa45724b7 100644
--- a/src/sire/search/__init__.py
+++ b/src/sire/search/__init__.py
@@ -1,5 +1,10 @@
 __all__ = [
     "approx_equal",
+    "approx_greater",
+    "approx_greater_equal",
+    "approx_less",
+    "approx_less_equal",
+    "approx_not_equal",
     "delete_all_tokens",
     "delete_token",
     "get_approx_epsilon",
@@ -19,6 +24,11 @@
 
 from ..legacy.Search import (
     approx_equal,
+    approx_greater,
+    approx_greater_equal,
+    approx_less,
+    approx_less_equal,
+    approx_not_equal,
     set_approx_epsilon,
     get_approx_epsilon,
     get_min_protein_residues,
diff --git a/src/sire/system/_system.py b/src/sire/system/_system.py
index 5948ced7e..20c00d2a7 100644
--- a/src/sire/system/_system.py
+++ b/src/sire/system/_system.py
@@ -85,6 +85,10 @@ def num_molecules(self):
         """Return the number of molecules in this System"""
         return self._system.num_molecules()
 
+    def find(self, views):
+        """Return the index(es) of the molecule(s) that are in `views`"""
+        return self.molecules().find(views)
+
     def names(self):
         """Return the names of all of the molecules in this System"""
         return self.molecules().names()
diff --git a/src/sire/units/__init__.py b/src/sire/units/__init__.py
index 231bacb0c..8a44875d3 100644
--- a/src/sire/units/__init__.py
+++ b/src/sire/units/__init__.py
@@ -9,23 +9,147 @@
     "set_quantity_unit",
     "set_si_units",
     "set_time_unit",
+    "GeneralUnit",
+    "akma_time",
+    "akma_velocity",
+    "amp",
+    "angle_minute",
+    "angle_minutes",
+    "angle_second",
+    "angle_seconds",
     "angstrom",
+    "angstroms",
+    "angstrom2",
+    "angstrom3",
+    "angstroms_per_fs",
+    "atm",
+    "atomic_mass_constant",
+    "bar",
+    "bohr_radii",
+    "c",
+    "cal",
+    "cal_per_mol",
     "celsius",
+    "centimeter",
+    "centimeters",
+    "circumference",
+    "convert",
+    "coulomb",
+    "coulomb_per_mol",
+    "day",
+    "degree",
     "degrees",
+    "e_charge",
+    "electron_mass",
+    "epsilon0",
     "fahrenheit",
     "farad",
+    "faraday",
+    "feet",
+    "femtogram",
     "femtosecond",
+    "fg_per_mol",
+    "fortnight",
+    "four_pi_eps0",
+    "g_accel",
     "g_per_mol",
+    "gasr",
+    "grad",
+    "gradian",
+    "gradians",
+    "gram",
+    "gon",
+    "G_newton",
+    "h_planck",
+    "h_slash",
+    "hartree",
+    "hour",
+    "hundredweight",
+    "inch",
+    "int_cal",
+    "int_cal_per_mol",
+    "int_kcal",
+    "int_kcal_per_mol",
+    "joule",
+    "J_per_mol",
+    "k_boltz",
+    "kcal",
     "kcal_per_mol",
+    "kelvin",
+    "kilogram",
+    "kilojoule",
+    "kilometer",
+    "kilometers",
+    "kilometers_per_hour",
+    "kg_per_mol",
     "kJ_per_mol",
-    "mod_electron",
+    "kph",
+    "megajoule",
     "meter",
+    "meter2",
+    "meter3",
+    "meters",
+    "meters_per_second",
+    "mg_per_mol",
+    "microgram",
+    "micrometer",
+    "microsecond",
+    "miles",
+    "miles_per_hour",
+    "milligram",
+    "millimeter",
+    "millimeters",
+    "millisecond",
+    "minute",
+    "mmHg",
+    "mod_electron",
+    "molar_volume",
+    "mole",
+    "mph",
+    "mu0",
+    "MJ_per_mol",
+    "nanogram",
     "nanometer",
+    "nanometers",
     "nanometer2",
     "nanosecond",
+    "neutron_mass",
+    "newton",
+    "ng_per_mol",
+    "octant",
+    "octants",
+    "one_over_four_pi_eps0",
+    "ounce",
+    "pascal",
+    "pg_per_mol",
+    "picogram",
     "picometer",
+    "picometers",
+    "picometer2",
+    "picometer3",
     "picosecond",
+    "pound",
+    "proton_mass",
+    "psi",
+    "quadrant",
+    "quadrants",
+    "radian",
     "radians",
+    "revolution",
+    "revolutions",
+    "revs",
+    "second",
+    "sextant",
+    "sextants",
+    "stone",
+    "tonne",
+    "tonne_per_mol",
+    "ug_per_mol",
+    "volt",
+    "watt",
+    "watt_per_mol",
+    "week",
+    "yards",
 ]
 
 from ..legacy import Units as _Units
@@ -33,33 +157,146 @@
 from .. import use_new_api as _use_new_api
 
 from ..legacy.Units import (
+    akma_time,
+    akma_velocity,
+    amp,
+    angle_minute,
+    angle_minutes,
+    angle_second,
+    angle_seconds,
     angstrom,
+    angstroms,
+    angstrom2,
+    angstrom3,
+    angstroms_per_fs,
+    atm,
+    atomic_mass_constant,
+    bar,
+    bohr_radii,
+    c,
     cal,
+    cal_per_mol,
     celsius,
+    centimeter,
+    centimeters,
+    circumference,
     convert,
+    coulomb,
+    coulomb_per_mol,
+    day,
+    degree,
     degrees,
+    e_charge,
+    electron_mass,
+    epsilon0,
     fahrenheit,
     farad,
+    faraday,
+    feet,
+    femtogram,
     femtosecond,
+    fg_per_mol,
+    fortnight,
+    four_pi_eps0,
+    g_accel,
     g_per_mol,
+    gasr,
+    grad,
+    gradian,
+    gradians,
     gram,
-    joule,
-    mod_electron,
-    meter,
+    gon,
+    G_newton,
+    h_planck,
+    h_slash,
+    hartree,
+    hour,
+    hundredweight,
+    inch,
     int_cal,
+    int_cal_per_mol,
     int_kcal,
+    int_kcal_per_mol,
+    joule,
+    J_per_mol,
+    k_boltz,
     kcal,
     kcal_per_mol,
+    kelvin,
     kilogram,
     kilojoule,
+    kilometer,
+    kilometers,
+    kilometers_per_hour,
+    kg_per_mol,
     kJ_per_mol,
+    kph,
+    megajoule,
+    meter,
+    meter2,
+    meter3,
+    meters,
+    meters_per_second,
+    mg_per_mol,
+    microgram,
+    micrometer,
+    microsecond,
+    miles,
+    miles_per_hour,
+    milligram,
+    millimeter,
+    millimeters,
+    millisecond,
+    minute,
+    mmHg,
+    mod_electron,
+    molar_volume,
     mole,
+    mph,
+    mu0,
+    MJ_per_mol,
+    nanogram,
     nanometer,
+    nanometers,
     nanometer2,
     nanosecond,
+    neutron_mass,
+    newton,
+    ng_per_mol,
+    octant,
+    octants,
+    one_over_four_pi_eps0,
+    ounce,
+    pascal,
+    pg_per_mol,
+    picogram,
     picometer,
+    picometers,
+    picometer2,
+    picometer3,
     picosecond,
+    pound,
+    proton_mass,
+    psi,
+    quadrant,
+    quadrants,
+    radian,
     radians,
+    revolution,
+    revolutions,
+    revs,
+    second,
+    sextant,
+    sextants,
+    stone,
+    tonne,
+    tonne_per_mol,
+    ug_per_mol,
+    volt,
+    watt,
+    watt_per_mol,
+    week,
+    yards,
     GeneralUnit,
 )
 
diff --git a/tests/mol/test_find.py b/tests/mol/test_find.py
new file mode 100644
index 000000000..1e0d996ac
--- /dev/null
+++ b/tests/mol/test_find.py
@@ -0,0 +1,31 @@
+import pytest
+
+
+def test_find(ala_mols):
+
+    mols = ala_mols
+
+    assert mols.atoms().find(mols.atoms()[0]) == 0
+
+    assert mols.atoms().find(mols.atoms()[1000]) == 1000
+
+    assert mols.atoms().find(mols.atoms()[10:100]) == list(range(10, 100))
+
+    idxs = mols.atoms().find(mols["element C"])
+
+    assert len(idxs) == len(mols["element C"])
+
+    for idx in idxs:
+        assert mols.atoms()[idx].element().num_protons() == 6
+
+    assert mols.residues().find(mols["resname ALA"]) == 1
+
+    assert mols.find(mols[600]) == 600
+
+    assert mols.find(mols[3:50:3]) == list(range(3, 50, 3))
+
+    with pytest.raises(IndexError):
+        mols[1:].find(mols[0])
+
+    with pytest.raises(IndexError):
+        mols[1:].atoms().find(mols["element C"])
diff --git a/wrapper/Mol/Atom.pypp.cpp b/wrapper/Mol/Atom.pypp.cpp
index 61327a54a..4eb4a032f 100644
--- a/wrapper/Mol/Atom.pypp.cpp
+++ b/wrapper/Mol/Atom.pypp.cpp
@@ -94,6 +94,8 @@ namespace bp = boost::python;
 
 #include "atomproperty.hpp"
 
+#include "SireMol/core.h"
+
 const SireMM::LJParameter& get_Metadata_SireMM_AtomLJs_function1(const SireMol::Atom &atom,
                                    const QString &metakey){ return atom.metadata< SireMM::LJParameter >(metakey); }
 
diff --git a/wrapper/Mol/Bead.pypp.cpp b/wrapper/Mol/Bead.pypp.cpp
index bdac5958c..fe1f04f04 100644
--- a/wrapper/Mol/Bead.pypp.cpp
+++ b/wrapper/Mol/Bead.pypp.cpp
@@ -42,6 +42,8 @@ namespace bp = boost::python;
 
 #include "beadproperty.hpp"
 
+#include "SireMol/core.h"
+
 const QString& get_Metadata_SireMol_BeadStringProperty_function1(const SireMol::Bead &atom,
                                    const QString &metakey){ return atom.metadata< QString >(metakey); }
 
diff --git a/wrapper/Mol/Chain.pypp.cpp b/wrapper/Mol/Chain.pypp.cpp
index 9ce0e5144..1ce7097a8 100644
--- a/wrapper/Mol/Chain.pypp.cpp
+++ b/wrapper/Mol/Chain.pypp.cpp
@@ -39,6 +39,8 @@ namespace bp = boost::python;
 
 #include "chainproperty.hpp"
 
+#include "SireMol/core.h"
+
 const QString& get_Metadata_SireMol_ChainStringProperty_function1(const SireMol::Chain &atom,
                                    const QString &metakey){ return atom.metadata< QString >(metakey); }
 
diff --git a/wrapper/Mol/CutGroup.pypp.cpp b/wrapper/Mol/CutGroup.pypp.cpp
index e19cd758a..9303a025d 100644
--- a/wrapper/Mol/CutGroup.pypp.cpp
+++ b/wrapper/Mol/CutGroup.pypp.cpp
@@ -40,6 +40,8 @@ namespace bp = boost::python;
 
 #include "cgproperty.hpp"
 
+#include "SireMol/core.h"
+
 const QString& get_Metadata_SireMol_CGStringProperty_function1(const SireMol::CutGroup &atom,
                                    const QString &metakey){ return atom.metadata< QString >(metakey); }
 
diff --git a/wrapper/Mol/Residue.pypp.cpp b/wrapper/Mol/Residue.pypp.cpp
index 9983880d5..430476f5d 100644
--- a/wrapper/Mol/Residue.pypp.cpp
+++ b/wrapper/Mol/Residue.pypp.cpp
@@ -41,6 +41,8 @@ namespace bp = boost::python;
 
 #include "resproperty.hpp"
 
+#include "SireMol/core.h"
+
 const QString& get_Metadata_SireMol_ResStringProperty_function1(const SireMol::Residue &atom,
                                    const QString &metakey){ return atom.metadata< QString >(metakey); }
 
diff --git a/wrapper/Mol/Segment.pypp.cpp b/wrapper/Mol/Segment.pypp.cpp
index 0858959d5..8e6dbbeed 100644
--- a/wrapper/Mol/Segment.pypp.cpp
+++ b/wrapper/Mol/Segment.pypp.cpp
@@ -36,6 +36,8 @@ namespace bp = boost::python;
 
 #include "segproperty.hpp"
 
+#include "SireMol/core.h"
+
 const QString& get_Metadata_SireMol_SegStringProperty_function1(const SireMol::Segment &atom,
                                    const QString &metakey){ return atom.metadata< QString >(metakey); }
 
diff --git a/wrapper/Mol/SelectorM_Atom_.pypp.cpp b/wrapper/Mol/SelectorM_Atom_.pypp.cpp
index 8c82a8db6..5595754ae 100644
--- a/wrapper/Mol/SelectorM_Atom_.pypp.cpp
+++ b/wrapper/Mol/SelectorM_Atom_.pypp.cpp
@@ -579,6 +579,48 @@ void register_SelectorM_Atom__class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::SelectorM< SireMol::Atom >::find
+        
+            typedef SireMol::SelectorM< SireMol::Atom > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Atom >::*find_function_type)( ::SireMol::Atom const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Atom >::find );
+            
+            SelectorM_Atom__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorM< SireMol::Atom >::find
+        
+            typedef SireMol::SelectorM< SireMol::Atom > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Atom >::*find_function_type)( ::SireMol::Selector< SireMol::Atom > const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Atom >::find );
+            
+            SelectorM_Atom__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorM< SireMol::Atom >::find
+        
+            typedef SireMol::SelectorM< SireMol::Atom > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Atom >::*find_function_type)( ::SireMol::SelectorM< SireMol::Atom > const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Atom >::find );
+            
+            SelectorM_Atom__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::SelectorM< SireMol::Atom >::indexes
         
diff --git a/wrapper/Mol/SelectorM_Chain_.pypp.cpp b/wrapper/Mol/SelectorM_Chain_.pypp.cpp
index a07980d3c..b3a917790 100644
--- a/wrapper/Mol/SelectorM_Chain_.pypp.cpp
+++ b/wrapper/Mol/SelectorM_Chain_.pypp.cpp
@@ -579,6 +579,48 @@ void register_SelectorM_Chain__class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::SelectorM< SireMol::Chain >::find
+        
+            typedef SireMol::SelectorM< SireMol::Chain > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Chain >::*find_function_type)( ::SireMol::Chain const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Chain >::find );
+            
+            SelectorM_Chain__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorM< SireMol::Chain >::find
+        
+            typedef SireMol::SelectorM< SireMol::Chain > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Chain >::*find_function_type)( ::SireMol::Selector< SireMol::Chain > const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Chain >::find );
+            
+            SelectorM_Chain__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorM< SireMol::Chain >::find
+        
+            typedef SireMol::SelectorM< SireMol::Chain > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Chain >::*find_function_type)( ::SireMol::SelectorM< SireMol::Chain > const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Chain >::find );
+            
+            SelectorM_Chain__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::SelectorM< SireMol::Chain >::indexes
         
diff --git a/wrapper/Mol/SelectorM_CutGroup_.pypp.cpp b/wrapper/Mol/SelectorM_CutGroup_.pypp.cpp
index 33161f3bd..2cb0a019b 100644
--- a/wrapper/Mol/SelectorM_CutGroup_.pypp.cpp
+++ b/wrapper/Mol/SelectorM_CutGroup_.pypp.cpp
@@ -579,6 +579,48 @@ void register_SelectorM_CutGroup__class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::SelectorM< SireMol::CutGroup >::find
+        
+            typedef SireMol::SelectorM< SireMol::CutGroup > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::CutGroup >::*find_function_type)( ::SireMol::CutGroup const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::CutGroup >::find );
+            
+            SelectorM_CutGroup__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorM< SireMol::CutGroup >::find
+        
+            typedef SireMol::SelectorM< SireMol::CutGroup > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::CutGroup >::*find_function_type)( ::SireMol::Selector< SireMol::CutGroup > const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::CutGroup >::find );
+            
+            SelectorM_CutGroup__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorM< SireMol::CutGroup >::find
+        
+            typedef SireMol::SelectorM< SireMol::CutGroup > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::CutGroup >::*find_function_type)( ::SireMol::SelectorM< SireMol::CutGroup > const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::CutGroup >::find );
+            
+            SelectorM_CutGroup__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::SelectorM< SireMol::CutGroup >::indexes
         
diff --git a/wrapper/Mol/SelectorM_Residue_.pypp.cpp b/wrapper/Mol/SelectorM_Residue_.pypp.cpp
index 782ca3bc1..f10148a37 100644
--- a/wrapper/Mol/SelectorM_Residue_.pypp.cpp
+++ b/wrapper/Mol/SelectorM_Residue_.pypp.cpp
@@ -579,6 +579,48 @@ void register_SelectorM_Residue__class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::SelectorM< SireMol::Residue >::find
+        
+            typedef SireMol::SelectorM< SireMol::Residue > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Residue >::*find_function_type)( ::SireMol::Residue const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Residue >::find );
+            
+            SelectorM_Residue__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorM< SireMol::Residue >::find
+        
+            typedef SireMol::SelectorM< SireMol::Residue > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Residue >::*find_function_type)( ::SireMol::Selector< SireMol::Residue > const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Residue >::find );
+            
+            SelectorM_Residue__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorM< SireMol::Residue >::find
+        
+            typedef SireMol::SelectorM< SireMol::Residue > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Residue >::*find_function_type)( ::SireMol::SelectorM< SireMol::Residue > const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Residue >::find );
+            
+            SelectorM_Residue__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::SelectorM< SireMol::Residue >::indexes
         
diff --git a/wrapper/Mol/SelectorM_Segment_.pypp.cpp b/wrapper/Mol/SelectorM_Segment_.pypp.cpp
index 2b6984953..76e147759 100644
--- a/wrapper/Mol/SelectorM_Segment_.pypp.cpp
+++ b/wrapper/Mol/SelectorM_Segment_.pypp.cpp
@@ -579,6 +579,48 @@ void register_SelectorM_Segment__class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::SelectorM< SireMol::Segment >::find
+        
+            typedef SireMol::SelectorM< SireMol::Segment > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Segment >::*find_function_type)( ::SireMol::Segment const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Segment >::find );
+            
+            SelectorM_Segment__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorM< SireMol::Segment >::find
+        
+            typedef SireMol::SelectorM< SireMol::Segment > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Segment >::*find_function_type)( ::SireMol::Selector< SireMol::Segment > const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Segment >::find );
+            
+            SelectorM_Segment__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorM< SireMol::Segment >::find
+        
+            typedef SireMol::SelectorM< SireMol::Segment > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::SelectorM< SireMol::Segment >::*find_function_type)( ::SireMol::SelectorM< SireMol::Segment > const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorM< SireMol::Segment >::find );
+            
+            SelectorM_Segment__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::SelectorM< SireMol::Segment >::indexes
         
diff --git a/wrapper/Mol/SelectorMol.pypp.cpp b/wrapper/Mol/SelectorMol.pypp.cpp
index 69de8f0ce..5a3a75ad2 100644
--- a/wrapper/Mol/SelectorMol.pypp.cpp
+++ b/wrapper/Mol/SelectorMol.pypp.cpp
@@ -474,6 +474,32 @@ void register_SelectorMol_class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::SelectorMol::find
+        
+            typedef ::QList< long long > ( ::SireMol::SelectorMol::*find_function_type)( ::SireMol::Molecule const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorMol::find );
+            
+            SelectorMol_exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::SelectorMol::find
+        
+            typedef ::QList< long long > ( ::SireMol::SelectorMol::*find_function_type)( ::SireMol::SelectorMol const & ) const;
+            find_function_type find_function_value( &::SireMol::SelectorMol::find );
+            
+            SelectorMol_exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::SelectorMol::indexes
         
diff --git a/wrapper/Mol/Selector_Atom_.pypp.cpp b/wrapper/Mol/Selector_Atom_.pypp.cpp
index 4ee98ab8c..9a5f3b2dd 100644
--- a/wrapper/Mol/Selector_Atom_.pypp.cpp
+++ b/wrapper/Mol/Selector_Atom_.pypp.cpp
@@ -45,6 +45,8 @@ namespace bp = boost::python;
 
 #include "atom.h"
 
+#include "SireMol/core.h"
+
 SireMol::Selector<SireMol::Atom> __copy__(const SireMol::Selector<SireMol::Atom> &other){ return SireMol::Selector<SireMol::Atom>(other); }
 
 #include "Qt/qdatastream.hpp"
@@ -204,6 +206,48 @@ void register_Selector_Atom__class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::Selector< SireMol::Atom >::find
+        
+            typedef SireMol::Selector< SireMol::Atom > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Atom >::*find_function_type)( ::SireMol::Atom const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Atom >::find );
+            
+            Selector_Atom__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::Selector< SireMol::Atom >::find
+        
+            typedef SireMol::Selector< SireMol::Atom > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Atom >::*find_function_type)( ::SireMol::Selector< SireMol::Atom > const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Atom >::find );
+            
+            Selector_Atom__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::Selector< SireMol::Atom >::find
+        
+            typedef SireMol::Selector< SireMol::Atom > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Atom >::*find_function_type)( ::SireMol::SelectorM< SireMol::Atom > const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Atom >::find );
+            
+            Selector_Atom__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::Selector< SireMol::Atom >::hasMetadata
         
diff --git a/wrapper/Mol/Selector_Chain_.pypp.cpp b/wrapper/Mol/Selector_Chain_.pypp.cpp
index 69e297c92..1c7701aad 100644
--- a/wrapper/Mol/Selector_Chain_.pypp.cpp
+++ b/wrapper/Mol/Selector_Chain_.pypp.cpp
@@ -37,6 +37,8 @@ namespace bp = boost::python;
 
 #include "chain.h"
 
+#include "SireMol/core.h"
+
 SireMol::Selector<SireMol::Chain> __copy__(const SireMol::Selector<SireMol::Chain> &other){ return SireMol::Selector<SireMol::Chain>(other); }
 
 #include "Qt/qdatastream.hpp"
@@ -196,6 +198,48 @@ void register_Selector_Chain__class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::Selector< SireMol::Chain >::find
+        
+            typedef SireMol::Selector< SireMol::Chain > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Chain >::*find_function_type)( ::SireMol::Chain const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Chain >::find );
+            
+            Selector_Chain__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::Selector< SireMol::Chain >::find
+        
+            typedef SireMol::Selector< SireMol::Chain > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Chain >::*find_function_type)( ::SireMol::Selector< SireMol::Chain > const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Chain >::find );
+            
+            Selector_Chain__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::Selector< SireMol::Chain >::find
+        
+            typedef SireMol::Selector< SireMol::Chain > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Chain >::*find_function_type)( ::SireMol::SelectorM< SireMol::Chain > const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Chain >::find );
+            
+            Selector_Chain__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::Selector< SireMol::Chain >::hasMetadata
         
diff --git a/wrapper/Mol/Selector_CutGroup_.pypp.cpp b/wrapper/Mol/Selector_CutGroup_.pypp.cpp
index d12737098..e1204ca27 100644
--- a/wrapper/Mol/Selector_CutGroup_.pypp.cpp
+++ b/wrapper/Mol/Selector_CutGroup_.pypp.cpp
@@ -37,6 +37,8 @@ namespace bp = boost::python;
 
 #include "cutgroup.h"
 
+#include "SireMol/core.h"
+
 SireMol::Selector<SireMol::CutGroup> __copy__(const SireMol::Selector<SireMol::CutGroup> &other){ return SireMol::Selector<SireMol::CutGroup>(other); }
 
 #include "Qt/qdatastream.hpp"
@@ -196,6 +198,48 @@ void register_Selector_CutGroup__class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::Selector< SireMol::CutGroup >::find
+        
+            typedef SireMol::Selector< SireMol::CutGroup > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::CutGroup >::*find_function_type)( ::SireMol::CutGroup const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::CutGroup >::find );
+            
+            Selector_CutGroup__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::Selector< SireMol::CutGroup >::find
+        
+            typedef SireMol::Selector< SireMol::CutGroup > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::CutGroup >::*find_function_type)( ::SireMol::Selector< SireMol::CutGroup > const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::CutGroup >::find );
+            
+            Selector_CutGroup__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::Selector< SireMol::CutGroup >::find
+        
+            typedef SireMol::Selector< SireMol::CutGroup > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::CutGroup >::*find_function_type)( ::SireMol::SelectorM< SireMol::CutGroup > const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::CutGroup >::find );
+            
+            Selector_CutGroup__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::Selector< SireMol::CutGroup >::hasMetadata
         
diff --git a/wrapper/Mol/Selector_Residue_.pypp.cpp b/wrapper/Mol/Selector_Residue_.pypp.cpp
index 70ea1b1f4..ed25f804b 100644
--- a/wrapper/Mol/Selector_Residue_.pypp.cpp
+++ b/wrapper/Mol/Selector_Residue_.pypp.cpp
@@ -39,6 +39,8 @@ namespace bp = boost::python;
 
 #include "residue.h"
 
+#include "SireMol/core.h"
+
 SireMol::Selector<SireMol::Residue> __copy__(const SireMol::Selector<SireMol::Residue> &other){ return SireMol::Selector<SireMol::Residue>(other); }
 
 #include "Qt/qdatastream.hpp"
@@ -198,6 +200,48 @@ void register_Selector_Residue__class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::Selector< SireMol::Residue >::find
+        
+            typedef SireMol::Selector< SireMol::Residue > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Residue >::*find_function_type)( ::SireMol::Residue const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Residue >::find );
+            
+            Selector_Residue__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::Selector< SireMol::Residue >::find
+        
+            typedef SireMol::Selector< SireMol::Residue > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Residue >::*find_function_type)( ::SireMol::Selector< SireMol::Residue > const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Residue >::find );
+            
+            Selector_Residue__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::Selector< SireMol::Residue >::find
+        
+            typedef SireMol::Selector< SireMol::Residue > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Residue >::*find_function_type)( ::SireMol::SelectorM< SireMol::Residue > const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Residue >::find );
+            
+            Selector_Residue__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::Selector< SireMol::Residue >::hasMetadata
         
diff --git a/wrapper/Mol/Selector_Segment_.pypp.cpp b/wrapper/Mol/Selector_Segment_.pypp.cpp
index a822286d5..3d2c08d4c 100644
--- a/wrapper/Mol/Selector_Segment_.pypp.cpp
+++ b/wrapper/Mol/Selector_Segment_.pypp.cpp
@@ -33,6 +33,8 @@ namespace bp = boost::python;
 
 #include "segment.h"
 
+#include "SireMol/core.h"
+
 SireMol::Selector<SireMol::Segment> __copy__(const SireMol::Selector<SireMol::Segment> &other){ return SireMol::Selector<SireMol::Segment>(other); }
 
 #include "Qt/qdatastream.hpp"
@@ -192,6 +194,48 @@ void register_Selector_Segment__class(){
                 , bp::release_gil_policy()
                 , "" );
         
+        }
+        { //::SireMol::Selector< SireMol::Segment >::find
+        
+            typedef SireMol::Selector< SireMol::Segment > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Segment >::*find_function_type)( ::SireMol::Segment const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Segment >::find );
+            
+            Selector_Segment__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("view") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::Selector< SireMol::Segment >::find
+        
+            typedef SireMol::Selector< SireMol::Segment > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Segment >::*find_function_type)( ::SireMol::Selector< SireMol::Segment > const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Segment >::find );
+            
+            Selector_Segment__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
+        }
+        { //::SireMol::Selector< SireMol::Segment >::find
+        
+            typedef SireMol::Selector< SireMol::Segment > exported_class_t;
+            typedef ::QList< long long > ( ::SireMol::Selector< SireMol::Segment >::*find_function_type)( ::SireMol::SelectorM< SireMol::Segment > const & ) const;
+            find_function_type find_function_value( &::SireMol::Selector< SireMol::Segment >::find );
+            
+            Selector_Segment__exposer.def( 
+                "find"
+                , find_function_value
+                , ( bp::arg("views") )
+                , bp::release_gil_policy()
+                , "" );
+        
         }
         { //::SireMol::Selector< SireMol::Segment >::hasMetadata
         
diff --git a/wrapper/Mol/special_code.py b/wrapper/Mol/special_code.py
index 174582b7e..7a00c0cec 100644
--- a/wrapper/Mol/special_code.py
+++ b/wrapper/Mol/special_code.py
@@ -25,11 +25,18 @@
 return_const = "bp::return_value_policy<bp::copy_const_reference>()"
 return_self = "bp::return_self< >()"
 
+def fix_Selector(c):
+   #add in the core header files
+   c.add_declaration_code( "#include \"SireMol/core.h\"" )
+
 def fix_MolView(c, molview, props):
    #now add in all of the header files
    for header in props.dependencies():
        c.add_declaration_code( "#include %s" % header )
 
+   #add in the core header files
+   c.add_declaration_code( "#include \"SireMol/core.h\"" )
+
    #add accessor functions for all of the view properties
    for property in props.properties():
        p = property[0]
@@ -448,6 +455,12 @@ def fix_SelectResultMover(c):
 
                  "SireMol::PerturbationSymbols" : fix_PerturbationSymbols,
 
+                 "SireMol::Selector<SireMol::Atom>" : fix_Selector,
+                 "SireMol::Selector<SireMol::Residue>" : fix_Selector,
+                 "SireMol::Selector<SireMol::CutGroup>" : fix_Selector,
+                 "SireMol::Selector<SireMol::Chain>" : fix_Selector,
+                 "SireMol::Selector<SireMol::Segment>" : fix_Selector,
+
                  "SireMol::CGIdx" : fix_CGIdx,
                  "SireMol::CGAtomIdx" : fix_CGAtomIdx }
 
diff --git a/wrapper/Units/Celsius.pypp.cpp b/wrapper/Units/Celsius.pypp.cpp
index e74593d53..a0ce9d00e 100644
--- a/wrapper/Units/Celsius.pypp.cpp
+++ b/wrapper/Units/Celsius.pypp.cpp
@@ -11,6 +11,8 @@ namespace bp = boost::python;
 
 #include "temperature.h"
 
+#include "generalunit.h"
+
 SireUnits::Celsius __copy__(const SireUnits::Celsius &other){ return SireUnits::Celsius(other); }
 
 #include "Helpers/str.hpp"
@@ -67,13 +69,17 @@ void register_Celsius_class(){
         }
         Celsius_exposer.def( bp::self * bp::other< double >() );
         Celsius_exposer.def( bp::self * bp::other< int >() );
+        Celsius_exposer.def( bp::self * bp::other< SireUnits::Dimension::GeneralUnit >() );
         Celsius_exposer.def( bp::self + bp::self );
         Celsius_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 1, 0, 0 > >() );
+        Celsius_exposer.def( bp::self + bp::other< SireUnits::Dimension::GeneralUnit >() );
         Celsius_exposer.def( -bp::self );
         Celsius_exposer.def( bp::self - bp::self );
         Celsius_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 1, 0, 0 > >() );
+        Celsius_exposer.def( bp::self - bp::other< SireUnits::Dimension::GeneralUnit >() );
         Celsius_exposer.def( bp::self / bp::other< double >() );
         Celsius_exposer.def( bp::self / bp::other< int >() );
+        Celsius_exposer.def( bp::self / bp::other< SireUnits::Dimension::GeneralUnit >() );
         { //::SireUnits::Celsius::operator=
         
             typedef ::SireUnits::Celsius & ( ::SireUnits::Celsius::*assign_function_type)( ::SireUnits::Celsius const & ) ;
@@ -108,6 +114,10 @@ void register_Celsius_class(){
         Celsius_exposer.def( bp::other<double>() - bp::self );
         Celsius_exposer.def( bp::other<double>() * bp::self );
         Celsius_exposer.def( bp::other<double>() / bp::self );
+        Celsius_exposer.def( bp::self + bp::other<SireUnits::Dimension::GeneralUnit>() );
+        Celsius_exposer.def( bp::self - bp::other<SireUnits::Dimension::GeneralUnit>() );
+        Celsius_exposer.def( bp::self * bp::other<SireUnits::Dimension::GeneralUnit>() );
+        Celsius_exposer.def( bp::self / bp::other<SireUnits::Dimension::GeneralUnit>() );
         Celsius_exposer.def( "__copy__", &__copy__);
         Celsius_exposer.def( "__deepcopy__", &__copy__);
         Celsius_exposer.def( "clone", &__copy__);
diff --git a/wrapper/Units/Fahrenheit.pypp.cpp b/wrapper/Units/Fahrenheit.pypp.cpp
index d7e8a09fc..6a0712189 100644
--- a/wrapper/Units/Fahrenheit.pypp.cpp
+++ b/wrapper/Units/Fahrenheit.pypp.cpp
@@ -11,6 +11,8 @@ namespace bp = boost::python;
 
 #include "temperature.h"
 
+#include "generalunit.h"
+
 SireUnits::Fahrenheit __copy__(const SireUnits::Fahrenheit &other){ return SireUnits::Fahrenheit(other); }
 
 #include "Helpers/str.hpp"
@@ -67,13 +69,17 @@ void register_Fahrenheit_class(){
         }
         Fahrenheit_exposer.def( bp::self * bp::other< double >() );
         Fahrenheit_exposer.def( bp::self * bp::other< int >() );
+        Fahrenheit_exposer.def( bp::self * bp::other< SireUnits::Dimension::GeneralUnit >() );
         Fahrenheit_exposer.def( bp::self + bp::self );
         Fahrenheit_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 1, 0, 0 > >() );
+        Fahrenheit_exposer.def( bp::self + bp::other< SireUnits::Dimension::GeneralUnit >() );
         Fahrenheit_exposer.def( -bp::self );
         Fahrenheit_exposer.def( bp::self - bp::self );
         Fahrenheit_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 1, 0, 0 > >() );
+        Fahrenheit_exposer.def( bp::self - bp::other< SireUnits::Dimension::GeneralUnit >() );
         Fahrenheit_exposer.def( bp::self / bp::other< double >() );
         Fahrenheit_exposer.def( bp::self / bp::other< int >() );
+        Fahrenheit_exposer.def( bp::self / bp::other< SireUnits::Dimension::GeneralUnit >() );
         { //::SireUnits::Fahrenheit::operator=
         
             typedef ::SireUnits::Fahrenheit & ( ::SireUnits::Fahrenheit::*assign_function_type)( ::SireUnits::Fahrenheit const & ) ;
@@ -104,6 +110,10 @@ void register_Fahrenheit_class(){
         Fahrenheit_exposer.def( bp::other<double>() - bp::self );
         Fahrenheit_exposer.def( bp::other<double>() * bp::self );
         Fahrenheit_exposer.def( bp::other<double>() / bp::self );
+        Fahrenheit_exposer.def( bp::self + bp::other<SireUnits::Dimension::GeneralUnit>() );
+        Fahrenheit_exposer.def( bp::self - bp::other<SireUnits::Dimension::GeneralUnit>() );
+        Fahrenheit_exposer.def( bp::self * bp::other<SireUnits::Dimension::GeneralUnit>() );
+        Fahrenheit_exposer.def( bp::self / bp::other<SireUnits::Dimension::GeneralUnit>() );
         Fahrenheit_exposer.def( "__copy__", &__copy__);
         Fahrenheit_exposer.def( "__deepcopy__", &__copy__);
         Fahrenheit_exposer.def( "clone", &__copy__);
diff --git a/wrapper/Units/GeneralUnit.pypp.cpp b/wrapper/Units/GeneralUnit.pypp.cpp
index c996cdd75..545017de6 100644
--- a/wrapper/Units/GeneralUnit.pypp.cpp
+++ b/wrapper/Units/GeneralUnit.pypp.cpp
@@ -29,6 +29,8 @@ namespace bp = boost::python;
 
 #include "generalunit.h"
 
+#include "generalunit.h"
+
 SireUnits::Dimension::GeneralUnit __copy__(const SireUnits::Dimension::GeneralUnit &other){ return SireUnits::Dimension::GeneralUnit(other); }
 
 #include "Qt/qdatastream.hpp"
@@ -45,6 +47,11 @@ void register_GeneralUnit_class(){
         bp::scope GeneralUnit_scope( GeneralUnit_exposer );
         GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::TempBase const & >(( bp::arg("temperature") ), "") );
         GeneralUnit_exposer.def( bp::init< double >(( bp::arg("value") ), "") );
+        GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< -1, -3, 2, 2, 0, 0, 0 > const & >(( bp::arg("unit") ), "") );
+        GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, -1, -1, 0 > const & >(( bp::arg("unit") ), "") );
+        GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 1, 1, 0, -2, 0, 0, 0 > const & >(( bp::arg("unit") ), "") );
+        GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< -1, 3, -2, 0, 0, 0, 0 > const & >(( bp::arg("unit") ), "") );
+        GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 1, 2, -1, 0, 0, 0, 0 > const & >(( bp::arg("unit") ), "") );
         GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::GeneralUnit const & >(( bp::arg("other") ), "") );
         { //::SireUnits::Dimension::GeneralUnit::ANGLE
         
@@ -243,18 +250,20 @@ void register_GeneralUnit_class(){
         }
         GeneralUnit_exposer.def( bp::self != bp::self );
         GeneralUnit_exposer.def( bp::self * bp::self );
+        GeneralUnit_exposer.def( bp::self * bp::other< SireUnits::Dimension::TempBase >() );
         GeneralUnit_exposer.def( bp::self * bp::other< double >() );
         GeneralUnit_exposer.def( bp::self * bp::other< int >() );
-        GeneralUnit_exposer.def( bp::self *= bp::self );
         GeneralUnit_exposer.def( bp::self + bp::self );
+        GeneralUnit_exposer.def( bp::self + bp::other< SireUnits::Dimension::TempBase >() );
         GeneralUnit_exposer.def( bp::self + bp::other< double >() );
         GeneralUnit_exposer.def( -bp::self );
         GeneralUnit_exposer.def( bp::self - bp::self );
+        GeneralUnit_exposer.def( bp::self - bp::other< SireUnits::Dimension::TempBase >() );
         GeneralUnit_exposer.def( bp::self - bp::other< double >() );
         GeneralUnit_exposer.def( bp::self / bp::self );
+        GeneralUnit_exposer.def( bp::self / bp::other< SireUnits::Dimension::TempBase >() );
         GeneralUnit_exposer.def( bp::self / bp::other< double >() );
         GeneralUnit_exposer.def( bp::self / bp::other< int >() );
-        GeneralUnit_exposer.def( bp::self /= bp::self );
         GeneralUnit_exposer.def( bp::self < bp::self );
         GeneralUnit_exposer.def( bp::self <= bp::self );
         { //::SireUnits::Dimension::GeneralUnit::operator=
diff --git a/wrapper/Units/SireUnits_registrars.cpp b/wrapper/Units/SireUnits_registrars.cpp
index 5b6447a20..10f00bf6f 100644
--- a/wrapper/Units/SireUnits_registrars.cpp
+++ b/wrapper/Units/SireUnits_registrars.cpp
@@ -41,6 +41,11 @@ void register_SireUnits_objects()
     ObjectRegistry::registerConverterFor< SireUnits::Dimension::Capacitance >();
     ObjectRegistry::registerConverterFor< SireUnits::Dimension::Current >();
     ObjectRegistry::registerConverterFor< SireUnits::Dimension::Potential >();
+    ObjectRegistry::registerConverterFor< SireUnits::Dimension::Constant1 >();
+    ObjectRegistry::registerConverterFor< SireUnits::Dimension::Constant2 >();
+    ObjectRegistry::registerConverterFor< SireUnits::Dimension::Constant3 >();
+    ObjectRegistry::registerConverterFor< SireUnits::Dimension::Constant4 >();
+    ObjectRegistry::registerConverterFor< SireUnits::Dimension::Constant5 >();
     ObjectRegistry::registerConverterFor< SireUnits::Dimension::GeneralUnit >();
 
 }
diff --git a/wrapper/Units/TempBase.pypp.cpp b/wrapper/Units/TempBase.pypp.cpp
index 771618de8..1b49921d5 100644
--- a/wrapper/Units/TempBase.pypp.cpp
+++ b/wrapper/Units/TempBase.pypp.cpp
@@ -11,6 +11,8 @@ namespace bp = boost::python;
 
 #include "temperature.h"
 
+#include "generalunit.h"
+
 #include "Helpers/str.hpp"
 
 #include "Helpers/release_gil_policy.hpp"
diff --git a/wrapper/Units/special_code.py b/wrapper/Units/special_code.py
index a8bd9cb93..56175fa87 100644
--- a/wrapper/Units/special_code.py
+++ b/wrapper/Units/special_code.py
@@ -7,13 +7,14 @@
 
 import re
 
+
 def findGlobals():
-    #read in the information about this module
+    # read in the information about this module
     lines = open("module_info", "r").readlines()
     root = lines[2].split()[1]
     sourcedir = lines[1].split()[1]
 
-    lines = open("%s/%s/units.h" % (root,sourcedir), "r").readlines()
+    lines = open("%s/%s/units.h" % (root, sourcedir), "r").readlines()
 
     FILE = open("_Units_global_variables.pyman.hpp", "w")
 
@@ -26,10 +27,10 @@ def findGlobals():
 
     FILE = open("_Units_global_variables.pyman.cpp", "w")
 
-    print("\n#include \"_Units_global_variables.pyman.hpp\"", file=FILE)
+    print('\n#include "_Units_global_variables.pyman.hpp"', file=FILE)
     print("#include <boost/python.hpp>", file=FILE)
-    print("#include \"SireUnits/units.h\"", file=FILE)
-    print("#include \"SireUnits/temperature.h\"", file=FILE)
+    print('#include "SireUnits/units.h"', file=FILE)
+    print('#include "SireUnits/temperature.h"', file=FILE)
     print("\nusing namespace boost::python;", file=FILE)
     print("using namespace SireUnits;", file=FILE)
     print("using namespace SireUnits::Dimension;\n", file=FILE)
@@ -37,54 +38,84 @@ def findGlobals():
     print("void register_man_global_variables()", file=FILE)
     print("{", file=FILE)
 
-
     for line in lines:
         match = re.search(r"const Dimension::([\w\d\-<,>]+)\s+(\w+)", line)
 
         if match:
             name = match.group(2)
-            print("    scope().attr(\"%s\") = %s;\n" % (name,name), file=FILE)
+            print('    scope().attr("%s") = %s;\n' % (name, name), file=FILE)
         else:
-            match = re.search(r"const double\s+(\w+)", line)
+            match = re.search(r"const GeneralUnit\s+(\w+)", line)
 
             if match:
                 name = match.group(1)
-                print("    scope().attr(\"%s\") = %s;\n" % (name,name), file=FILE)
-
+                print(
+                    '    scope().attr("%s") = %s;\n' % (name, name), file=FILE
+                )
 
-
-    #add Celsius and Fahrenheit manually
-    print("    scope().attr(\"celsius\") = celsius;\n", file=FILE)
-    print("    scope().attr(\"fahrenheit\") = fahrenheit;\n", file=FILE)
+    # add Celsius and Fahrenheit manually
+    print('    scope().attr("celsius") = celsius;\n', file=FILE)
+    print('    scope().attr("fahrenheit") = fahrenheit;\n', file=FILE)
 
     print("}\n", file=FILE)
 
+
 def fix_GeneralUnit(c):
     c.add_registration_code("def( bp::other<double>() + bp::self )")
     c.add_registration_code("def( bp::other<double>() - bp::self )")
     c.add_registration_code("def( bp::other<double>() * bp::self )")
     c.add_registration_code("def( bp::other<double>() / bp::self )")
 
-def fixMB(mb):
-   mb.add_declaration_code("#include \"SireUnits/temperature.h\"")
-   mb.add_declaration_code("#include \"sireunits_dimensions.h\"")
-   mb.add_declaration_code("#include \"generalunit.h\"")
-   mb.add_declaration_code("#include \"_Units_global_variables.pyman.hpp\"")
+    c.add_declaration_code('#include "generalunit.h"')
 
 
-   mb.add_registration_code("register_SireUnits_dimensions();")
-   mb.add_registration_code("register_man_global_variables();")
+def fix_Temperature(c):
+    c.add_registration_code("def( bp::other<double>() + bp::self )")
+    c.add_registration_code("def( bp::other<double>() - bp::self )")
+    c.add_registration_code("def( bp::other<double>() * bp::self )")
+    c.add_registration_code("def( bp::other<double>() / bp::self )")
+
+    c.add_declaration_code('#include "generalunit.h"')
+
+    c.add_registration_code(
+        "def( bp::self + bp::other<SireUnits::Dimension::GeneralUnit>() )"
+    )
+    c.add_registration_code(
+        "def( bp::self - bp::other<SireUnits::Dimension::GeneralUnit>() )"
+    )
+    c.add_registration_code(
+        "def( bp::self * bp::other<SireUnits::Dimension::GeneralUnit>() )"
+    )
+    c.add_registration_code(
+        "def( bp::self / bp::other<SireUnits::Dimension::GeneralUnit>() )"
+    )
+
+
+def fix_TempBase(c):
+    c.add_declaration_code('#include "generalunit.h"')
+
+
+def fixMB(mb):
+    mb.add_declaration_code('#include "SireUnits/temperature.h"')
+    mb.add_declaration_code('#include "sireunits_dimensions.h"')
+    mb.add_declaration_code('#include "generalunit.h"')
+    mb.add_declaration_code('#include "_Units_global_variables.pyman.hpp"')
 
-   #add all of the global physical constants to the module
-   findGlobals()
+    mb.add_registration_code("register_SireUnits_dimensions();")
+    mb.add_registration_code("register_man_global_variables();")
 
+    # add all of the global physical constants to the module
+    findGlobals()
 
-special_code = { "SireUnits::Dimension::GeneralUnit" : fix_GeneralUnit,
-                 "SireUnits::Celsius" : fix_GeneralUnit,
-                 "SireUnits::Fahrenheit" : fix_GeneralUnit }
 
-implicitly_convertible = [ ("SireUnits::Dimension::TempBase",
-                            "SireUnits::Dimension::Temperature"),
-                           ("double", "SireUnits::Dimension::GeneralUnit"),
-                         ]
+special_code = {
+    "SireUnits::Dimension::GeneralUnit": fix_GeneralUnit,
+    "SireUnits::Celsius": fix_Temperature,
+    "SireUnits::Fahrenheit": fix_Temperature,
+    "SireUnits::Dimension::TempBase": fix_TempBase,
+}
 
+implicitly_convertible = [
+    ("SireUnits::Dimension::TempBase", "SireUnits::Dimension::Temperature"),
+    ("double", "SireUnits::Dimension::GeneralUnit"),
+]