Documentation

sire is implemented as a primary module, with a collection of submodules.

You import sire using;

>>> import sire as sr

This imports the main module, which is the primary gateway into all of the functionality of sire.

This is designed so that you (mostly) only need to call functions from this main module. These functions will create objects and call functions from the various sub-modules. You will rarely need to call functions or create classes from the sub-modules directly yourself.

For example, sire.load() will use the file parsers defined in sire.io to load molecules (each represented as a Molecule object from sire.mol), and will return the result as a System (defined in sire.system).

Key sub-modules are:

• sire.mol - defines all of the objects that are used to represent and manipulate molecules (and views of molecules).

• sire.search - provides the power behind the search functionality.

• sire.units - implements a complete set of units so that all physical quantities are represented by proper units / dimensions.

• sire.maths - provides a collection of maths functions and classes (e.g. points in space, represented via sire.maths.Vector, or spheres, represented via sire.maths.Sphere).

• sire.cas - this is a complete computer algebra system (CAS), used to flexibly define interaction functions for calculating energies and forces between atoms and molecules.

• sire.io - all of the input/output classes used to read and write molecular data to and from files.

• sire.mm - a set of molecular mechanics (MM) forcefields that enables sire to rapidly calculate energies and forces between atoms and molecules.

• sire.base - a set of base classes and functions that includes a property system with associated containers for flexibly holding and manipulating objects of different types, and mapping them between the C++ and Python layers of sire.

• sire.stream - provides functions that support streaming (pickling) of all sire objects to an from a cross-platform, versioned binary format. This allows all C++ objects to be pickled via standard Python pickle.

• sire.vol - provides different spaces (volumes) that can be used to calculate distances between points with different boundary conditions.

• sire.utils - a miscellaneous collection of utilities that are Python-only, and don’t fit neatly into any of the other sub-modules.

Top-level documentation

• sire module
  • Public API
    • atomid()
    • chainid()
    • expand()
    • get_max_num_threads()
    • load()
    • load_test_files()
    • match_atoms()
    • measure()
    • minimum_distance()
    • molid()
    • save()
    • save_to_string()
    • segid()
    • set_default_num_threads()
    • set_max_num_threads()
    • smarts()
    • smiles()
    • sqrt()
    • supported_formats()
    • u()
    • use_mixed_api()
    • use_new_api()
    • use_old_api()
    • v()
    • tutorial_url

Sub-module documentation

• Sub-modules
  • sire.base
  • sire.cas
  • sire.convert
  • sire.io
  • sire.maths
  • sire.mm
  • sire.mol
  • sire.morph
  • sire.restraints
  • sire.search
  • sire.stream
  • sire.system
  • sire.units
  • sire.utils
  • sire.vol